void TheoreticalSpectrumGenerator::addIsotopeCluster_(RichPeakSpectrum & spectrum, const AASequence & ion, Residue::ResidueType res_type, Int charge, double intensity) const { double pos = ion.getMonoWeight(res_type, charge) / (double)charge; RichPeak1D p; IsotopeDistribution dist = ion.getFormula(res_type, charge).getIsotopeDistribution(max_isotope_); UInt j(0); for (IsotopeDistribution::ConstIterator it = dist.begin(); it != dist.end(); ++it, ++j) { // TODO: this is usually dominated by 13C-12C mass shift which deviates a bit from neutron mass p.setMZ((double)(pos + (double)j * Constants::NEUTRON_MASS_U) / (double)charge); p.setIntensity(intensity * it->second); if (add_metainfo_ && j == 0) { String ion_name = String(residueTypeToIonLetter_(res_type)) + String(ion.size()) + String(charge, '+'); p.setMetaValue("IonName", ion_name); } spectrum.push_back(p); } }
void getAveragineIsotopeDistribution(double product_mz, std::vector<std::pair<double, double> >& isotopesSpec, double charge, int nr_isotopes, double mannmass) { typedef OpenMS::FeatureFinderAlgorithmPickedHelperStructs::TheoreticalIsotopePattern TheoreticalIsotopePattern; // create the theoretical distribution IsotopeDistribution d; TheoreticalIsotopePattern isotopes; d.setMaxIsotope(nr_isotopes); //std::cout << product_mz * charge << std::endl; d.estimateFromPeptideWeight(product_mz * charge); double mass = product_mz; for (IsotopeDistribution::Iterator it = d.begin(); it != d.end(); ++it) { isotopesSpec.push_back(std::make_pair(mass, it->second)); mass += mannmass; } } //end of dia_isotope_corr_sub
void ElementDB::readFromFile_(const String& file_name) { String file = File::find(file_name); // load elements into param object Param param; ParamXMLFile paramFile; paramFile.load(file, param); UInt an(0); String name, symbol; // determine prefix vector<String> split; param.begin().getName().split(':', split); String prefix(""); for (Size i = 0; i < split.size() - 1; ++i) { prefix += split[i] + ":"; } //cout << "first element prefix=" << prefix << endl; Map<UInt, double> Z_to_abundancy; Map<UInt, double> Z_to_mass; for (Param::ParamIterator it = param.begin(); it != param.end(); ++it) { // new element started? if (!it.getName().hasPrefix(prefix)) { // update prefix it.getName().split(':', split); prefix = ""; for (Size i = 0; i < split.size() - 1; ++i) { prefix += split[i] + ":"; } // cout << "new element prefix=" << prefix << endl; // Parsing of previous element is finished. Now store data in Element object IsotopeDistribution isotopes = parseIsotopeDistribution_(Z_to_abundancy); double avg_weight = calculateAvgWeight_(Z_to_abundancy, Z_to_mass); double mono_weight = calculateMonoWeight_(Z_to_mass); /* // print information about elements cout << "Name: " << name << " AtomicNumber: " << an << " Symbol: " << symbol << " AvgWeight: " << avg_weight << " MonoWeight: " << mono_weight << " NIsotopes: " << isotopes.size() << endl; */ Element* e = new Element(name, symbol, an, avg_weight, mono_weight, isotopes); names_[name] = e; symbols_[symbol] = e; atomic_numbers_[an] = e; // add all the individual isotopes as separat elements for (IsotopeDistribution::ConstIterator iit = isotopes.begin(); iit != isotopes.end(); ++iit) { String iso_name = "(" + String(iit->first) + ")" + name; String iso_symbol = "(" + String(iit->first) + ")" + symbol; // set avg and mono to same value for isotopes (old hack...) DoubleReal iso_avg_weight = Z_to_mass[(UInt) iit->first]; DoubleReal iso_mono_weight = iso_avg_weight; IsotopeDistribution iso_isotopes; vector<pair<Size, double> > iso_container; iso_container.push_back(make_pair(iit->first, 1.0)); iso_isotopes.set(iso_container); /* // print name, symbal and atomic mass of the current isotope cout << "Isotope Name: " << iso_name << " Symbol: " << iso_symbol << " AtomicMass: " << iso_mono_weight << endl; */ Element* iso_e = new Element(iso_name, iso_symbol, an, iso_avg_weight, iso_mono_weight, iso_isotopes); names_[iso_name] = iso_e; names_[iso_symbol] = iso_e; } Z_to_abundancy.clear(); Z_to_mass.clear(); } // top level: read the contents of the element section it.getName().split(':', split); String key = split[2]; String value = it->value; value.trim(); // cout << "Key=" << key << endl; if (key == "AtomicNumber") { an = (UInt)value.toInt(); } else { if (key == "Isotopes") { UInt Z = UInt(split[3].toInt()); String item = split[4]; if (item == "RelativeAbundance") { Z_to_abundancy[Z] = double(value.toDouble() / 100.0); } else if (item == "AtomicMass") { Z_to_mass[Z] = double(value.toDouble()); } else { cerr << "read unknown item in Isotopes: " << item << endl; } } else { if (key == "Name") { name = value; } else { if (key == "Symbol") { symbol = value; } else { cerr << "read unknown tag: " << key << endl; } } } } } // build last element double avg_weight(0), mono_weight(0); IsotopeDistribution isotopes = parseIsotopeDistribution_(Z_to_abundancy); Element* e = new Element(name, symbol, an, avg_weight, mono_weight, isotopes); names_[name] = e; symbols_[symbol] = e; atomic_numbers_[an] = e; }
void TheoreticalSpectrumGenerator::addPrecursorPeaks(RichPeakSpectrum & spec, const AASequence & peptide, Int charge) const { RichPeak1D p; // precursor peak double mono_pos = peptide.getMonoWeight(Residue::Full, charge) / double(charge); if (add_isotopes_) { IsotopeDistribution dist = peptide.getFormula(Residue::Full, charge).getIsotopeDistribution(max_isotope_); UInt j(0); for (IsotopeDistribution::ConstIterator it = dist.begin(); it != dist.end(); ++it, ++j) { p.setMZ((double)(mono_pos + j * Constants::NEUTRON_MASS_U) / (double)charge); p.setIntensity(pre_int_ * it->second); if (add_metainfo_) { String name("[M+H]+"); if (charge == 2) { name = "[M+2H]++"; } p.setMetaValue("IonName", name); } spec.push_back(p); } } else { p.setMZ(mono_pos); p.setIntensity(pre_int_); if (add_metainfo_) { String name("[M+H]+"); if (charge == 2) { name = "[M+2H]++"; } p.setMetaValue("IonName", name); } spec.push_back(p); } // loss peaks of the precursor //loss of water EmpiricalFormula ion = peptide.getFormula(Residue::Full, charge) - EmpiricalFormula("H2O"); mono_pos = ion.getMonoWeight() / double(charge); if (add_isotopes_) { IsotopeDistribution dist = ion.getIsotopeDistribution(max_isotope_); UInt j(0); for (IsotopeDistribution::ConstIterator it = dist.begin(); it != dist.end(); ++it, ++j) { p.setMZ((double)(mono_pos + j * Constants::NEUTRON_MASS_U) / (double)charge); p.setIntensity(pre_int_H2O_ * it->second); if (add_metainfo_) { String name("[M+H]-H2O+"); if (charge == 2) { name = "[M+2H]-H2O++"; } p.setMetaValue("IonName", name); } spec.push_back(p); } } else { p.setMZ(mono_pos); p.setIntensity(pre_int_H2O_); if (add_metainfo_) { String name("[M+H]-H2O+"); if (charge == 2) { name = "[M+2H]-H2O++"; } p.setMetaValue("IonName", name); } spec.push_back(p); } //loss of ammonia ion = peptide.getFormula(Residue::Full, charge) - EmpiricalFormula("NH3"); mono_pos = ion.getMonoWeight() / double(charge); if (add_isotopes_) { IsotopeDistribution dist = ion.getIsotopeDistribution(max_isotope_); UInt j(0); for (IsotopeDistribution::ConstIterator it = dist.begin(); it != dist.end(); ++it, ++j) { p.setMZ((double)(mono_pos + j * Constants::NEUTRON_MASS_U) / (double)charge); p.setIntensity(pre_int_NH3_ * it->second); if (add_metainfo_) { String name("[M+H]-NH3+"); if (charge == 2) { name = "[M+2H]-NH3++"; } p.setMetaValue("IonName", name); } spec.push_back(p); } } else { p.setMZ(mono_pos); p.setIntensity(pre_int_NH3_); if (add_metainfo_) { String name("[M+H]-NH3+"); if (charge == 2) { name = "[M+2H]-NH3++"; } p.setMetaValue("IonName", name); } spec.push_back(p); } spec.sortByPosition(); }
void TheoreticalSpectrumGenerator::addLosses_(RichPeakSpectrum & spectrum, const AASequence & ion, double intensity, Residue::ResidueType res_type, int charge) const { RichPeak1D p; set<String> losses; for (AASequence::ConstIterator it = ion.begin(); it != ion.end(); ++it) { if (it->hasNeutralLoss()) { vector<EmpiricalFormula> loss_formulas = it->getLossFormulas(); for (Size i = 0; i != loss_formulas.size(); ++i) { losses.insert(loss_formulas[i].toString()); } } } if (!add_isotopes_) { p.setIntensity(intensity * rel_loss_intensity_); } for (set<String>::const_iterator it = losses.begin(); it != losses.end(); ++it) { EmpiricalFormula loss_ion = ion.getFormula(res_type, charge) - EmpiricalFormula(*it); // thanks to Chris and Sandro // check for negative element frequencies (might happen if losses are not allowed for specific ions) bool negative_elements(false); for (EmpiricalFormula::ConstIterator eit = loss_ion.begin(); eit != loss_ion.end(); ++eit) { if (eit->second < 0) { negative_elements = true; break; } } if (negative_elements) { continue; } double loss_pos = loss_ion.getMonoWeight() / (double)charge; const String& loss_name = *it; if (add_isotopes_) { IsotopeDistribution dist = loss_ion.getIsotopeDistribution(max_isotope_); UInt j(0); for (IsotopeDistribution::ConstIterator iso = dist.begin(); iso != dist.end(); ++iso) { p.setMZ((double)(loss_pos + j) / (double)charge); p.setIntensity(intensity * rel_loss_intensity_ * iso->second); if (add_metainfo_ && j == 0) { // note: important to construct a string from char. If omitted it will perform pointer arithmetics on the "-" string literal String ion_name = String(residueTypeToIonLetter_(res_type)) + String(ion.size()) + "-" + loss_name + String(charge, '+'); p.setMetaValue("IonName", ion_name); } spectrum.push_back(p); } } else { p.setMZ(loss_pos); if (add_metainfo_) { // note: important to construct a string from char. If omitted it will perform pointer arithmetics on the "-" string literal String ion_name = String(residueTypeToIonLetter_(res_type)) + String(ion.size()) + "-" + loss_name + String(charge, '+'); p.setMetaValue("IonName", ion_name); } spectrum.push_back(p); } } }
void TheoreticalSpectrumGenerator::addPrecursorPeaks(RichPeakSpectrum & spec, const AASequence & peptide, Int charge) { bool add_metainfo(param_.getValue("add_metainfo").toBool()); DoubleReal pre_int((DoubleReal)param_.getValue("precursor_intensity")); DoubleReal pre_int_H2O((DoubleReal)param_.getValue("precursor_H2O_intensity")); DoubleReal pre_int_NH3((DoubleReal)param_.getValue("precursor_NH3_intensity")); bool add_isotopes(param_.getValue("add_isotopes").toBool()); int max_isotope((int)param_.getValue("max_isotope")); // precursor peak DoubleReal mono_pos = peptide.getMonoWeight(Residue::Full, charge) / DoubleReal(charge); if (add_isotopes) { IsotopeDistribution dist = peptide.getFormula(Residue::Full, charge).getIsotopeDistribution(max_isotope); UInt j(0); for (IsotopeDistribution::ConstIterator it = dist.begin(); it != dist.end(); ++it, ++j) { p_.setMZ((DoubleReal)(mono_pos + j * Constants::NEUTRON_MASS_U) / (DoubleReal)charge); p_.setIntensity(pre_int * it->second); if (add_metainfo) { String name("[M+H]+"); if (charge == 2) { name = "[M+2H]++"; } p_.setMetaValue("IonName", name); } spec.push_back(p_); } } else { p_.setMZ(mono_pos); p_.setIntensity(pre_int); if (add_metainfo) { String name("[M+H]+"); if (charge == 2) { name = "[M+2H]++"; } p_.setMetaValue("IonName", name); } spec.push_back(p_); } // loss peaks of the precursor //loss of water EmpiricalFormula ion = peptide.getFormula(Residue::Full, charge) - EmpiricalFormula("H2O"); mono_pos = ion.getMonoWeight() / DoubleReal(charge); if (add_isotopes) { IsotopeDistribution dist = ion.getIsotopeDistribution(max_isotope); UInt j(0); for (IsotopeDistribution::ConstIterator it = dist.begin(); it != dist.end(); ++it, ++j) { p_.setMZ((DoubleReal)(mono_pos + j * Constants::NEUTRON_MASS_U) / (DoubleReal)charge); p_.setIntensity(pre_int_H2O * it->second); if (add_metainfo) { String name("[M+H]-H2O+"); if (charge == 2) { name = "[M+2H]-H2O++"; } p_.setMetaValue("IonName", name); } spec.push_back(p_); } } else { p_.setMZ(mono_pos); p_.setIntensity(pre_int_H2O); if (add_metainfo) { String name("[M+H]-H2O+"); if (charge == 2) { name = "[M+2H]-H2O++"; } p_.setMetaValue("IonName", name); } spec.push_back(p_); } //loss of ammonia ion = peptide.getFormula(Residue::Full, charge) - EmpiricalFormula("NH3"); mono_pos = ion.getMonoWeight() / DoubleReal(charge); if (add_isotopes) { IsotopeDistribution dist = ion.getIsotopeDistribution(max_isotope); UInt j(0); for (IsotopeDistribution::ConstIterator it = dist.begin(); it != dist.end(); ++it, ++j) { p_.setMZ((DoubleReal)(mono_pos + j * Constants::NEUTRON_MASS_U) / (DoubleReal)charge); p_.setIntensity(pre_int_NH3 * it->second); if (add_metainfo) { String name("[M+H]-NH3+"); if (charge == 2) { name = "[M+2H]-NH3++"; } p_.setMetaValue("IonName", name); } spec.push_back(p_); } } else { p_.setMZ(mono_pos); p_.setIntensity(pre_int_NH3); if (add_metainfo) { String name("[M+H]-NH3+"); if (charge == 2) { name = "[M+2H]-NH3++"; } p_.setMetaValue("IonName", name); } spec.push_back(p_); } spec.sortByPosition(); }
void TheoreticalSpectrumGenerator::addPeaks(RichPeakSpectrum & spectrum, const AASequence & peptide, Residue::ResidueType res_type, Int charge) { if (peptide.empty()) { return; } Map<DoubleReal, AASequence> ions; Map<DoubleReal, String> names; AASequence ion; DoubleReal intensity(0); bool add_first_prefix_ion(param_.getValue("add_first_prefix_ion").toBool()); // generate the ion peaks switch (res_type) { case Residue::AIon: { Size i = 1; if (!add_first_prefix_ion) { i = 2; } for (; i < peptide.size(); ++i) { ion = peptide.getPrefix(i); DoubleReal pos = ion.getMonoWeight(Residue::AIon, charge) / (DoubleReal)charge; ions[pos] = ion; names[pos] = "a" + String(i) + String(charge, '+'); } intensity = (DoubleReal)param_.getValue("a_intensity"); break; } case Residue::BIon: { Size i = 1; if (!add_first_prefix_ion) { i = 2; } for (; i < peptide.size(); ++i) { ion = peptide.getPrefix(i); DoubleReal pos = ion.getMonoWeight(Residue::BIon, charge) / (DoubleReal)charge; ions[pos] = ion; names[pos] = "b" + String(i) + String(charge, '+'); } intensity = (DoubleReal)param_.getValue("b_intensity"); break; } case Residue::CIon: { Size i = 1; if (!add_first_prefix_ion) { i = 2; } for (; i < peptide.size(); ++i) { ion = peptide.getPrefix(i); DoubleReal pos = ion.getMonoWeight(Residue::CIon, charge) / (DoubleReal)charge; ions[pos] = ion; names[pos] = "c" + String(i) + String(charge, '+'); } intensity = (DoubleReal)param_.getValue("c_intensity"); break; } case Residue::XIon: { for (Size i = 1; i < peptide.size(); ++i) { ion = peptide.getSuffix(i); DoubleReal pos = ion.getMonoWeight(Residue::XIon, charge) / (DoubleReal)charge; ions[pos] = ion; names[pos] = "x" + String(i) + String(charge, '+'); } intensity = (DoubleReal)param_.getValue("x_intensity"); break; } case Residue::YIon: { for (Size i = 1; i < peptide.size(); ++i) { ion = peptide.getSuffix(i); DoubleReal pos = ion.getMonoWeight(Residue::YIon, charge) / (DoubleReal)charge; ions[pos] = ion; names[pos] = "y" + String(i) + String(charge, '+'); } intensity = (DoubleReal)param_.getValue("y_intensity"); break; } case Residue::ZIon: { for (Size i = 1; i < peptide.size(); ++i) { ion = peptide.getSuffix(i); DoubleReal pos = ion.getMonoWeight(Residue::ZIon, charge) / (DoubleReal)charge; ions[pos] = ion; names[pos] = "z" + String(i) + String(charge, '+'); } intensity = (DoubleReal)param_.getValue("z_intensity"); break; } default: cerr << "Cannot create peaks of that ion type" << endl; } // get the params bool add_losses(param_.getValue("add_losses").toBool()); bool add_metainfo(param_.getValue("add_metainfo").toBool()); bool add_isotopes(param_.getValue("add_isotopes").toBool()); Int max_isotope((Int)param_.getValue("max_isotope")); DoubleReal rel_loss_intensity((DoubleReal)param_.getValue("relative_loss_intensity")); for (Map<DoubleReal, AASequence>::ConstIterator cit = ions.begin(); cit != ions.end(); ++cit) { ion = cit->second; DoubleReal pos = cit->first; String ion_name = names[pos]; if (add_isotopes) { IsotopeDistribution dist = ion.getFormula(res_type, charge).getIsotopeDistribution(max_isotope); UInt j(0); for (IsotopeDistribution::ConstIterator it = dist.begin(); it != dist.end(); ++it, ++j) { p_.setMZ((DoubleReal)(pos + (DoubleReal)j * Constants::NEUTRON_MASS_U) / (DoubleReal)charge); p_.setIntensity(intensity * it->second); if (add_metainfo && j == 0) { p_.setMetaValue("IonName", ion_name); } spectrum.push_back(p_); } } else { p_.setMZ(pos); p_.setIntensity(intensity); if (add_metainfo) { p_.setMetaValue("IonName", ion_name); } spectrum.push_back(p_); } if (add_losses) { set<String> losses; for (AASequence::ConstIterator it = cit->second.begin(); it != cit->second.end(); ++it) { if (it->hasNeutralLoss()) { vector<EmpiricalFormula> loss_formulas = it->getLossFormulas(); for (Size i = 0; i != loss_formulas.size(); ++i) { losses.insert(loss_formulas[i].toString()); } } } if (!add_isotopes) { p_.setIntensity(intensity * rel_loss_intensity); } for (set<String>::const_iterator it = losses.begin(); it != losses.end(); ++it) { EmpiricalFormula loss_ion = ion.getFormula(res_type, charge) - EmpiricalFormula(*it); // thanks to Chris and Sandro // check for negative element frequencies (might happen if losses are not allowed for specific ions) bool negative_elements(false); for (EmpiricalFormula::ConstIterator eit = loss_ion.begin(); eit != loss_ion.end(); ++eit) { if (eit->second < 0) { negative_elements = true; break; } } if (negative_elements) { continue; } DoubleReal loss_pos = loss_ion.getMonoWeight() / (DoubleReal)charge; String loss_name = *it; if (add_isotopes) { IsotopeDistribution dist = loss_ion.getIsotopeDistribution(max_isotope); UInt j(0); for (IsotopeDistribution::ConstIterator iso = dist.begin(); iso != dist.end(); ++iso) { p_.setMZ((DoubleReal)(loss_pos + j) / (DoubleReal)charge); p_.setIntensity(intensity * rel_loss_intensity * iso->second); if (add_metainfo && j == 0) { p_.setMetaValue("IonName", ion_name + "-" + loss_name); } spectrum.push_back(p_); } } else { p_.setMZ(loss_pos); if (add_metainfo) { p_.setMetaValue("IonName", ion_name + "-" + loss_name); } spectrum.push_back(p_); } } } } if (add_metainfo) { p_.setMetaValue("IonName", String("")); } spectrum.sortByPosition(); return; }
IsotopeDistributionCache::IsotopeDistributionCache(DoubleReal max_mass, DoubleReal mass_window_width, DoubleReal intensity_percentage, DoubleReal intensity_percentage_optional) : mass_window_width_(mass_window_width) { Size num_isotopes = std::ceil(max_mass / mass_window_width) + 1; //reserve enough space isotope_distributions_.resize(num_isotopes); //calculate distribution if necessary for (Size index = 0; index < num_isotopes; ++index) { //log_ << "Calculating iso dist for mass: " << 0.5*mass_window_width_ + index * mass_window_width_ << std::endl; IsotopeDistribution d; d.setMaxIsotope(20); d.estimateFromPeptideWeight(0.5 * mass_window_width + index * mass_window_width); //trim left and right. And store the number of isotopes on the left, to reconstruct the monoisotopic peak Size size_before = d.size(); d.trimLeft(intensity_percentage_optional); isotope_distributions_[index].trimmed_left = size_before - d.size(); d.trimRight(intensity_percentage_optional); for (IsotopeDistribution::Iterator it = d.begin(); it != d.end(); ++it) { isotope_distributions_[index].intensity.push_back(it->second); //log_ << " - " << it->second << std::endl; } //determine the number of optional peaks at the beginning/end Size begin = 0; Size end = 0; bool is_begin = true; bool is_end = false; for (Size i = 0; i < isotope_distributions_[index].intensity.size(); ++i) { if (isotope_distributions_[index].intensity[i] < intensity_percentage) { if (!is_end && !is_begin) is_end = true; if (is_begin) ++begin; else if (is_end) ++end; } else if (is_begin) { is_begin = false; } } isotope_distributions_[index].optional_begin = begin; isotope_distributions_[index].optional_end = end; //scale the distibution to a maximum of 1 DoubleReal max = 0.0; for (Size i = 0; i < isotope_distributions_[index].intensity.size(); ++i) { if (isotope_distributions_[index].intensity[i] > max) { max = isotope_distributions_[index].intensity[i]; } } isotope_distributions_[index].max = max; for (Size i = 0; i < isotope_distributions_[index].intensity.size(); ++i) { isotope_distributions_[index].intensity[i] /= max; } } }