void ChromatogramExtractor::prepare_coordinates(std::vector< OpenSwath::ChromatogramPtr > & output_chromatograms,
std::vector< ExtractionCoordinates > & coordinates,
OpenMS::TargetedExperiment & transition_exp_used,
bool enforce_presence_rt,
const bool ms1) const
{
// hash of the peptide reference containing all transitions
typedef std::map<String, std::vector<const ReactionMonitoringTransition*> > PeptideTransitionMapType;
PeptideTransitionMapType peptide_trans_map;
for (Size i = 0; i < transition_exp_used.getTransitions().size(); i++)
{
peptide_trans_map[transition_exp_used.getTransitions()[i].getPeptideRef()].push_back(&transition_exp_used.getTransitions()[i]);
}
// Determine iteration size (nr peptides or nr transitions)
Size itersize;
if (ms1) {itersize = transition_exp_used.getPeptides().size();}
else {itersize = transition_exp_used.getTransitions().size();}
for (Size i = 0; i < itersize; i++)
{
OpenSwath::ChromatogramPtr s(new OpenSwath::Chromatogram);
output_chromatograms.push_back(s);
ChromatogramExtractor::ExtractionCoordinates coord;
TargetedExperiment::Peptide pep;
OpenMS::ReactionMonitoringTransition transition;
if (ms1)
{
pep = transition_exp_used.getPeptides()[i];
transition = (*peptide_trans_map[pep.id][0]);
coord.mz = transition.getPrecursorMZ();
coord.id = pep.id;
}
else
{
transition = transition_exp_used.getTransitions()[i];
pep = transition_exp_used.getPeptideByRef(transition.getPeptideRef());
coord.mz = transition.getProductMZ();
coord.id = transition.getNativeID();
}
if (pep.rts.empty() || pep.rts[0].getCVTerms()["MS:1000896"].empty())
{
// we dont have retention times -> this is only a problem if we actually
// wanted to use the RT limit feature.
if (enforce_presence_rt)
{
throw Exception::IllegalArgument(__FILE__, __LINE__, __PRETTY_FUNCTION__,
"Error: Peptide " + pep.id + " does not have normalized retention times (term 1000896) which are necessary to perform an RT-limited extraction");
}
coord.rt = -1;
}
else
{
coord.rt = pep.rts[0].getCVTerms()["MS:1000896"][0].getValue().toString().toDouble();
// coord.rt = trafo.apply(coord.rt); // apply RT transformation if necessary
}
coordinates.push_back(coord);
}
// sort result
std::sort(coordinates.begin(), coordinates.end(), ChromatogramExtractor::ExtractionCoordinates::SortExtractionCoordinatesByMZ);
}
void MRMDecoy::generateDecoys(OpenMS::TargetedExperiment& exp, OpenMS::TargetedExperiment& dec,
String method, String decoy_tag, double identity_threshold, int max_attempts,
double mz_threshold, double mz_shift, bool exclude_similar,
double similarity_threshold, bool remove_CNterminal_mods, double precursor_mass_shift,
std::vector<String> fragment_types, std::vector<size_t> fragment_charges,
bool enable_specific_losses, bool enable_unspecific_losses, bool remove_unannotated,
int round_decPow)
{
MRMIonSeries mrmis;
MRMDecoy::PeptideVectorType peptides, decoy_peptides;
MRMDecoy::ProteinVectorType proteins, decoy_proteins;
MRMDecoy::TransitionVectorType decoy_transitions;
for (Size i = 0; i < exp.getProteins().size(); i++)
{
OpenMS::TargetedExperiment::Protein protein = exp.getProteins()[i];
protein.id = decoy_tag + protein.id;
proteins.push_back(protein);
}
std::vector<String> exclusion_peptides;
// Go through all peptides and apply the decoy method to the sequence
// (pseudo-reverse, reverse or shuffle). Then set the peptides and proteins of the decoy
// experiment.
for (Size pep_idx = 0; pep_idx < exp.getPeptides().size(); ++pep_idx)
{
OpenMS::TargetedExperiment::Peptide peptide = exp.getPeptides()[pep_idx];
// continue if the peptide has C/N terminal modifications and we should exclude them
if (remove_CNterminal_mods && MRMDecoy::has_CNterminal_mods(peptide)) {continue; }
peptide.id = decoy_tag + peptide.id;
OpenMS::String original_sequence = peptide.sequence;
if (!peptide.getPeptideGroupLabel().empty())
{
peptide.setPeptideGroupLabel(decoy_tag + peptide.getPeptideGroupLabel());
}
if (method == "pseudo-reverse")
{
peptide = MRMDecoy::pseudoreversePeptide(peptide);
}
else if (method == "reverse")
{
peptide = MRMDecoy::reversePeptide(peptide);
}
else if (method == "shuffle")
{
peptide = MRMDecoy::shufflePeptide(peptide, identity_threshold, -1, max_attempts);
}
for (Size prot_idx = 0; prot_idx < peptide.protein_refs.size(); ++prot_idx)
{
peptide.protein_refs[prot_idx] = decoy_tag + peptide.protein_refs[prot_idx];
}
if (MRMDecoy::AASequenceIdentity(original_sequence, peptide.sequence) > identity_threshold)
{
if (!exclude_similar)
{
std::cout << "Target sequence: " << original_sequence << " Decoy sequence: " << peptide.sequence << " Sequence identity: " << MRMDecoy::AASequenceIdentity(original_sequence, peptide.sequence) << " Identity threshold: " << identity_threshold << std::endl;
throw Exception::IllegalArgument(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "AA Sequences are too similar. Either decrease identity_threshold and increase max_attempts for the shuffle method or set flag exclude_similar.");
}
else
{
exclusion_peptides.push_back(peptide.id);
}
}
peptides.push_back(peptide);
}
dec.setPeptides(peptides); // temporary set peptides, overwrite later again!
// hash of the peptide reference containing all transitions
MRMDecoy::PeptideTransitionMapType peptide_trans_map;
for (Size i = 0; i < exp.getTransitions().size(); i++)
{
peptide_trans_map[exp.getTransitions()[i].getPeptideRef()].push_back(&exp.getTransitions()[i]);
}
Size progress = 0;
startProgress(0, exp.getTransitions().size(), "Creating decoys");
for (MRMDecoy::PeptideTransitionMapType::iterator pep_it = peptide_trans_map.begin();
pep_it != peptide_trans_map.end(); ++pep_it)
{
String peptide_ref = pep_it->first;
String decoy_peptide_ref = decoy_tag + pep_it->first; // see above, the decoy peptide id is computed deterministically from the target id
const TargetedExperiment::Peptide target_peptide = exp.getPeptideByRef(peptide_ref);
// continue if the peptide has C/N terminal modifications and we should exclude them
if (remove_CNterminal_mods && MRMDecoy::has_CNterminal_mods(target_peptide)) {continue;}
const TargetedExperiment::Peptide decoy_peptide = dec.getPeptideByRef(decoy_peptide_ref);
OpenMS::AASequence target_peptide_sequence = TargetedExperimentHelper::getAASequence(target_peptide);
OpenMS::AASequence decoy_peptide_sequence = TargetedExperimentHelper::getAASequence(decoy_peptide);
int decoy_charge = 1;
int target_charge = 1;
if (decoy_peptide.hasCharge()) {decoy_charge = decoy_peptide.getChargeState();}
if (target_peptide.hasCharge()) {target_charge = target_peptide.getChargeState();}
MRMIonSeries::IonSeries decoy_ionseries = mrmis.getIonSeries(decoy_peptide_sequence, decoy_charge, fragment_types, fragment_charges, enable_specific_losses, enable_unspecific_losses, round_decPow);
MRMIonSeries::IonSeries target_ionseries = mrmis.getIonSeries(target_peptide_sequence, target_charge, fragment_types, fragment_charges, enable_specific_losses, enable_unspecific_losses, round_decPow);
for (Size i = 0; i < pep_it->second.size(); i++)
{
setProgress(++progress);
const ReactionMonitoringTransition tr = *(pep_it->second[i]);
if (!tr.isDetectingTransition() || tr.getDecoyTransitionType() == ReactionMonitoringTransition::DECOY)
{
continue;
}
ReactionMonitoringTransition decoy_tr = tr; // copy the target transition
decoy_tr.setNativeID(decoy_tag + tr.getNativeID());
decoy_tr.setDecoyTransitionType(ReactionMonitoringTransition::DECOY);
decoy_tr.setPrecursorMZ(tr.getPrecursorMZ() + precursor_mass_shift); // fix for TOPPView: Duplicate precursor MZ is not displayed.
// determine the current annotation for the target ion and then select
// the appropriate decoy ion for this target transition
std::pair<String, double> targetion = mrmis.annotateIon(target_ionseries, tr.getProductMZ(), mz_threshold);
std::pair<String, double> decoyion = mrmis.getIon(decoy_ionseries, targetion.first);
if (method == "shift")
{
decoy_tr.setProductMZ(decoyion.second + mz_shift);
}
else
{
decoy_tr.setProductMZ(decoyion.second);
}
decoy_tr.setPeptideRef(decoy_tag + tr.getPeptideRef());
if (decoyion.second > 0)
{
if (similarity_threshold >= 0)
{
if (std::fabs(tr.getProductMZ() - decoy_tr.getProductMZ()) < similarity_threshold)
{
if (!exclude_similar)
{
throw Exception::IllegalArgument(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Fragment ions are too similar. Either decrease similarity_threshold or set flag exclude_similar.");
}
else
{
exclusion_peptides.push_back(decoy_tr.getPeptideRef());
}
}
}
decoy_transitions.push_back(decoy_tr);
}
else
{
if (remove_unannotated)
{
exclusion_peptides.push_back(decoy_tr.getPeptideRef());
}
else
{
throw Exception::IllegalArgument(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Decoy fragment ion for target fragment ion " + String(targetion.first) + " of peptide " + target_peptide_sequence.toString() + " with precursor charge " + String(target_peptide.getChargeState()) + " could not be mapped. Please check whether it is a valid ion and enable losses or removal of terminal modifications if necessary. Skipping of unannotated target assays is available as last resort.");
}
}
} // end loop over transitions
} // end loop over peptides
endProgress();
MRMDecoy::TransitionVectorType filtered_decoy_transitions;
for (MRMDecoy::TransitionVectorType::iterator tr_it = decoy_transitions.begin(); tr_it != decoy_transitions.end(); ++tr_it)
{
if (std::find(exclusion_peptides.begin(), exclusion_peptides.end(), tr_it->getPeptideRef()) == exclusion_peptides.end())
{
filtered_decoy_transitions.push_back(*tr_it);
}
}
dec.setTransitions(filtered_decoy_transitions);
std::vector<String> protein_ids;
for (Size i = 0; i < peptides.size(); ++i)
{
TargetedExperiment::Peptide peptide = peptides[i];
// Check if peptide has any transitions left
if (std::find(exclusion_peptides.begin(), exclusion_peptides.end(), peptide.id) == exclusion_peptides.end())
{
decoy_peptides.push_back(peptide);
for (Size j = 0; j < peptide.protein_refs.size(); ++j)
{
protein_ids.push_back(peptide.protein_refs[j]);
}
}
else
{
LOG_DEBUG << "[peptide] Skipping " << peptide.id << std::endl;
}
}
for (Size i = 0; i < proteins.size(); ++i)
{
OpenMS::TargetedExperiment::Protein protein = proteins[i];
// Check if protein has any peptides left
if (find(protein_ids.begin(), protein_ids.end(), protein.id) != protein_ids.end())
{
decoy_proteins.push_back(protein);
}
else
{
LOG_DEBUG << "[protein] Skipping " << protein.id << std::endl;
}
}
dec.setPeptides(decoy_peptides);
dec.setProteins(decoy_proteins);
}
void ChromatogramExtractor::return_chromatogram(std::vector< OpenSwath::ChromatogramPtr > & chromatograms,
std::vector< ChromatogramExtractor::ExtractionCoordinates > & coordinates,
OpenMS::TargetedExperiment & transition_exp_used, SpectrumSettings settings,
std::vector<OpenMS::MSChromatogram<> > & output_chromatograms, bool ms1) const
{
typedef std::map<String, const ReactionMonitoringTransition* > TransitionMapType;
TransitionMapType trans_map;
for (Size i = 0; i < transition_exp_used.getTransitions().size(); i++)
{
trans_map[transition_exp_used.getTransitions()[i].getNativeID()] = &transition_exp_used.getTransitions()[i];
}
for (Size i = 0; i < chromatograms.size(); i++)
{
const OpenSwath::ChromatogramPtr & chromptr = chromatograms[i];
const ChromatogramExtractor::ExtractionCoordinates & coord = coordinates[i];
TargetedExperiment::Peptide pep;
OpenMS::ReactionMonitoringTransition transition;
OpenMS::MSChromatogram<> chrom;
// copy data
OpenSwathDataAccessHelper::convertToOpenMSChromatogram(chrom, chromptr);
chrom.setNativeID(coord.id);
// Create precursor and set
// 1) the target m/z
// 2) the isolation window (upper/lower)
// 3) the peptide sequence
Precursor prec;
if (ms1)
{
pep = transition_exp_used.getPeptideByRef(coord.id);
prec.setMZ(coord.mz);
chrom.setChromatogramType(ChromatogramSettings::BASEPEAK_CHROMATOGRAM);
}
else
{
transition = (*trans_map[coord.id]);
pep = transition_exp_used.getPeptideByRef(transition.getPeptideRef());
prec.setMZ(transition.getPrecursorMZ());
if (settings.getPrecursors().size() > 0)
{
prec.setIsolationWindowLowerOffset(settings.getPrecursors()[0].getIsolationWindowLowerOffset());
prec.setIsolationWindowUpperOffset(settings.getPrecursors()[0].getIsolationWindowUpperOffset());
}
// Create product and set its m/z
Product prod;
prod.setMZ(transition.getProductMZ());
chrom.setProduct(prod);
chrom.setChromatogramType(ChromatogramSettings::SELECTED_REACTION_MONITORING_CHROMATOGRAM);
}
prec.setMetaValue("peptide_sequence", pep.sequence);
chrom.setPrecursor(prec);
// Set the rest of the meta-data
chrom.setInstrumentSettings(settings.getInstrumentSettings());
chrom.setAcquisitionInfo(settings.getAcquisitionInfo());
chrom.setSourceFile(settings.getSourceFile());
for (Size i = 0; i < settings.getDataProcessing().size(); ++i)
{
DataProcessing dp = settings.getDataProcessing()[i];
dp.setMetaValue("performed_on_spectra", "true");
chrom.getDataProcessing().push_back(dp);
}
output_chromatograms.push_back(chrom);
}
}