public void add_topdown_theoreticals(ProteinWithGoTerms prot, string seq, string accession, double unmodified_mass, int decoy_number, int lysine_count, List <TheoreticalProteoform> new_theoreticals, int ptm_set_counter, Dictionary <double, int> mod_ranks, int added_ptm_penalty) { foreach (TopDownProteoform topdown in Sweet.lollipop.topdown_proteoforms.Where(p => prot.AccessionList.Select(a => a.Split('_')[0]).Contains(p.accession.Split('_')[0].Split('-')[0]) && p.sequence == seq).OrderBy(t => t.accession).ThenByDescending(t => t.sequence.Length)) //order by gene name then descending sequence length --> order matters for creating theoreticals. { if (!new_theoreticals.Any(t => t.ptm_set.same_ptmset(topdown.topdown_ptm_set, true))) { //match each td proteoform group to the closest theoretical w/ best explanation.... otherwise make new theoretical proteoform PtmSet ptm_set = new PtmSet(topdown.topdown_ptm_set.ptm_combination, mod_ranks, added_ptm_penalty); TheoreticalProteoform t = new TheoreticalProteoform( accession + "_P" + ptm_set_counter.ToString(), prot.FullDescription + "_P" + ptm_set_counter.ToString() + (decoy_number < 0 ? "" : "_DECOY_" + decoy_number.ToString()), seq, (prot as ProteinSequenceGroup != null ? (prot as ProteinSequenceGroup).proteinWithGoTermList.ToArray() : new ProteinWithGoTerms[] { prot }), unmodified_mass, lysine_count, ptm_set, decoy_number < 0, false, theoretical_proteins); t.topdown_theoretical = true; new_theoreticals.Add(t); ptm_set_counter++; } } }
public AmbiguousIdentification(int begin, int end, PtmSet ptm_set, ProteoformRelation relation, TheoreticalProteoform theoretical_base, List <Proteoform> linked_proteoform_references) { this.begin = begin; this.end = end; this.relation = relation; this.theoretical_base = theoretical_base; this.ptm_set = ptm_set; this.linked_proteoform_references = linked_proteoform_references; }
public bool topdown_bottomup_comparison(ExperimentalProteoform pf1, TheoreticalProteoform pf2_with_allowed_lysines) { List <TopDownProteoform> topdown_proteoforms_same_accession = Sweet.lollipop.topdown_proteoforms.Where(td => pf2_with_allowed_lysines.ExpandedProteinList.Any(p => p.AccessionList.Select(a => a.Split('_')[0].Split('-')[0]) .Contains(td.accession.Split('_')[0].Split('-')[0]))).ToList(); bool good_BU_PSMs = topdown_proteoforms_same_accession.Count > 0 || pf2_with_allowed_lysines.bottom_up_PSMs.Count >= Sweet.lollipop.min_bu_peptides; return(good_BU_PSMs); }
public static string get_sequence(TheoreticalProteoform t, int begin, int end) { string sequence = t.sequence .Substring(begin < t.begin ? 0 : begin - t.begin, 1 + end - (begin < t.begin ? t.begin : begin)); if (begin < t.begin) { sequence = "M" + sequence; } return(sequence); }
public void set_correct_id() { if (linked_proteoform_references == null) { correct_id = false; } else { TheoreticalProteoform t = linked_proteoform_references.First() as TheoreticalProteoform; bool matching_accession = t.ExpandedProteinList.SelectMany(p => p.AccessionList).Select(a => a.Split('_')[0]).Contains(accession.Split('_')[0].Split('-')[0]); bool same_begin_and_end = begin == topdown_begin && end == topdown_end; bool same_ptm_set = topdown_ptm_set.same_ptmset(ptm_set, true); correct_id = matching_accession && same_ptm_set && same_begin_and_end; } }
public double calculate_mass_error(TheoreticalProteoform t, PtmSet ptm_set, int begin, int end) { string sequence = t.sequence .Substring(begin < t.begin ? 0 : begin - t.begin, 1 + end - (begin < t.begin ? t.begin : begin)); if (begin < t.begin) { sequence = "M" + sequence; } double theoretical_mass = TheoreticalProteoform.CalculateProteoformMass(sequence, ptm_set.ptm_combination); return(Math.Round(agg_mass - theoretical_mass, 4)); }
public List <ExperimentalProteoform> identify_connected_experimentals(TheoreticalProteoform theoretical_base, int begin, int end, PtmSet ptm_set, List <Proteoform> linked_proteoform_references) { List <ExperimentalProteoform> identified = new List <ExperimentalProteoform>(); //do relations first closest to candidate ptmset delta mass, then in order of relation delta mass (need to do in same order every round) foreach (ProteoformRelation r in relationships.Where(r => r.Accepted).OrderBy(r => r.candidate_ptmset != null ? Math.Abs(r.candidate_ptmset.mass - r.DeltaMass) : r.DeltaMass * 1e6).Distinct().ToList()) { ExperimentalProteoform e = r.connected_proteoforms.OfType <ExperimentalProteoform>().FirstOrDefault(p => p != this); if (e == null) { continue; } // Looking at an ET pair, expecting an EE pair //if (Sweet.lollipop.identify_from_td_nodes && this as TopDownProteoform != null && e as TopDownProteoform != null) continue; //between two TD nodes double mass_tolerance = modified_mass / 1000000 * Sweet.lollipop.mass_tolerance; PtmSet with_mod_change = determine_mod_change(e, this, theoretical_base, r, ptm_set, begin, end); if (with_mod_change == null && Math.Abs(r.peak.DeltaMass) <= mass_tolerance) { lock (r) lock (e) lock (this) { if (assign_pf_identity(e, ptm_set, begin, end, r, theoretical_base, linked_proteoform_references, true)) { r.Identification = true; identified.Add(e); } } continue; } if (with_mod_change == null) { continue; } lock (r) lock (e) lock (this) { if (assign_pf_identity(e, with_mod_change, begin, end, r, theoretical_base, linked_proteoform_references, true)) { r.Identification = true; identified.Add(e); } } } return(identified); }
public ProteoformRelation(Proteoform pf1, Proteoform pf2, ProteoformComparison relation_type, double delta_mass, string current_directory) { connected_proteoforms[0] = pf1; connected_proteoforms[1] = pf2; RelationType = relation_type; DeltaMass = delta_mass; InstanceId = instanceCounter; lock (SaveState.lollipop) instanceCounter += 1; //Not thread safe if (CH2 == null || HPO3 == null) { Loaders.LoadElements(Path.Combine(current_directory, "elements.dat")); CH2 = ChemicalFormula.ParseFormula("C1 H2"); HPO3 = ChemicalFormula.ParseFormula("H1 O3 P1"); } if (SaveState.lollipop.neucode_labeled) { lysine_count = pf1.lysine_count; } if ((relation_type == ProteoformComparison.ExperimentalTheoretical || relation_type == ProteoformComparison.ExperimentalDecoy) && SaveState.lollipop.theoretical_database.possible_ptmset_dictionary.TryGetValue(Math.Round(delta_mass, 1), out List <PtmSet> candidate_sets) && pf2 as TheoreticalProteoform != null) { TheoreticalProteoform t = pf2 as TheoreticalProteoform; double mass_tolerance = t.modified_mass / 1000000 * (double)SaveState.lollipop.mass_tolerance; List <PtmSet> narrower_range_of_candidates = candidate_sets.Where(s => Math.Abs(s.mass - delta_mass) < 0.05).ToList(); candidate_ptmset = t.generate_possible_added_ptmsets(narrower_range_of_candidates, delta_mass, mass_tolerance, SaveState.lollipop.theoretical_database.all_mods_with_mass, t, t.sequence, SaveState.lollipop.mod_rank_first_quartile) .OrderBy(x => x.ptm_rank_sum + Math.Abs(Math.Abs(x.mass) - Math.Abs(delta_mass)) * 10E-6) // major score: delta rank; tie breaker: deltaM, where it's always less than 1 .FirstOrDefault(); } // Start the model (0 Da) at the mass defect of CH2 or HPO3 itself, allowing the peak width tolerance on either side double half_peak_width = RelationType == ProteoformComparison.ExperimentalTheoretical || RelationType == ProteoformComparison.ExperimentalDecoy ? SaveState.lollipop.peak_width_base_et / 2 : SaveState.lollipop.peak_width_base_ee / 2; double low_decimal_bound = half_peak_width + ((CH2.MonoisotopicMass - Math.Truncate(CH2.MonoisotopicMass)) / CH2.MonoisotopicMass) * (Math.Abs(delta_mass) <= CH2.MonoisotopicMass ? CH2.MonoisotopicMass : Math.Abs(delta_mass)); double high_decimal_bound = 1 - half_peak_width + ((HPO3.MonoisotopicMass - Math.Ceiling(HPO3.MonoisotopicMass)) / HPO3.MonoisotopicMass) * (Math.Abs(delta_mass) <= HPO3.MonoisotopicMass ? HPO3.MonoisotopicMass : Math.Abs(delta_mass)); double delta_mass_decimal = Math.Abs(delta_mass - Math.Truncate(delta_mass)); outside_no_mans_land = delta_mass_decimal <= low_decimal_bound || delta_mass_decimal >= high_decimal_bound || high_decimal_bound <= low_decimal_bound; }
public List <ExperimentalProteoform> identify_connected_experimentals() { List <ExperimentalProteoform> identified = new List <ExperimentalProteoform>(); //do relations first closest to candidate ptmset delta mass, then in order of relation delta mass (need to do in same order every round) foreach (ProteoformRelation r in relationships.Where(r => r.Accepted).OrderBy(r => r.candidate_ptmset != null ? Math.Abs(r.candidate_ptmset.mass - r.DeltaMass) : r.DeltaMass * 1e6).Distinct().ToList()) { ExperimentalProteoform e = r.connected_proteoforms.OfType <ExperimentalProteoform>().FirstOrDefault(p => p != this); if (e == null) { continue; } // Looking at an ET pair, expecting an EE pair TheoreticalProteoform theoretical_base = this as TheoreticalProteoform != null ? this as TheoreticalProteoform : //Theoretical starting point (linked_proteoform_references.First() as TheoreticalProteoform != null ? linked_proteoform_references.First() as TheoreticalProteoform : //Experimental with theoretical reference null); //Experimental without theoretical reference double mass_tolerance = modified_mass / 1000000 * Sweet.lollipop.mass_tolerance; PtmSet with_mod_change = determine_mod_change(e, this, theoretical_base, r, this.ptm_set); if (with_mod_change == null && Math.Abs(r.peak.DeltaMass) <= mass_tolerance) { lock (r) lock (e) assign_pf_identity(e, ptm_set, r, theoretical_base); identified.Add(e); } if (with_mod_change == null) { continue; } lock (r) lock (e) assign_pf_identity(e, with_mod_change, r, theoretical_base); identified.Add(e); } return(identified); }
public List <ExperimentalProteoform> identify_connected_experimentals(List <PtmSet> all_possible_ptmsets, List <ModificationWithMass> all_mods_with_mass) { List <ExperimentalProteoform> identified = new List <ExperimentalProteoform>(); foreach (ProteoformRelation r in relationships.Where(r => r.Accepted).Distinct().ToList()) { ExperimentalProteoform e = r.connected_proteoforms.OfType <ExperimentalProteoform>().FirstOrDefault(p => p != this); if (e == null) { continue; // Looking at an ET pair, expecting an EE pair } double mass_tolerance = modified_mass / 1000000 * (double)SaveState.lollipop.mass_tolerance; int sign = Math.Sign(e.modified_mass - modified_mass); double deltaM = Math.Sign(r.peak.DeltaMass) < 0 ? r.peak.DeltaMass : sign * r.peak.DeltaMass; // give EE relations the correct sign, but don't switch negative ET relation deltaM's TheoreticalProteoform theoretical_base = this as TheoreticalProteoform != null ? this as TheoreticalProteoform : //Theoretical starting point (linked_proteoform_references.First() as TheoreticalProteoform != null ? linked_proteoform_references.First() as TheoreticalProteoform : //Experimental with theoretical reference null); //Experimental without theoretical reference string theoretical_base_sequence = theoretical_base != null ? theoretical_base.sequence : ""; PtmSet best_addition = generate_possible_added_ptmsets(r.peak.possiblePeakAssignments, deltaM, mass_tolerance, all_mods_with_mass, theoretical_base, theoretical_base_sequence, 1) .OrderBy(x => (double)x.ptm_rank_sum + Math.Abs(x.mass - deltaM) * 10E-6) // major score: delta rank; tie breaker: deltaM, where it's always less than 1 .FirstOrDefault(); PtmSet best_loss = null; foreach (PtmSet set in all_possible_ptmsets) { bool within_loss_tolerance = deltaM >= -set.mass - mass_tolerance && deltaM <= -set.mass + mass_tolerance; var these_mods = this.ptm_set.ptm_combination.Select(ptm => ptm.modification); var those_mods = set.ptm_combination.Select(ptm => ptm.modification); // all must be in the current set to remove them bool can_be_removed = those_mods.All(m => these_mods.Contains(m)); bool better_than_current_best_loss = best_loss == null || Math.Abs(deltaM - (-set.mass)) < Math.Abs(deltaM - (-best_loss.mass)); if (can_be_removed && within_loss_tolerance && better_than_current_best_loss) { best_loss = set; } } // If they're the same and someone hasn't labeled 0 difference with a "ModificationWithMass", then label it null if (best_addition == null && best_loss == null && Math.Abs(r.peak.DeltaMass) <= mass_tolerance) { lock (r) lock (e) assign_pf_identity(e, this, ptm_set, r, sign, null); identified.Add(e); } if (best_addition == null && best_loss == null) { continue; } // Make the new ptmset with ptms removed or added PtmSet with_mod_change = null; if (best_loss == null) { with_mod_change = new PtmSet(new List <Ptm>(this.ptm_set.ptm_combination.Concat(best_addition.ptm_combination).Where(ptm => ptm.modification.monoisotopicMass != 0).ToList())); } else { List <Ptm> new_combo = new List <Ptm>(this.ptm_set.ptm_combination); foreach (Ptm ptm in best_loss.ptm_combination) { new_combo.Remove(new_combo.FirstOrDefault(asdf => asdf.modification == ptm.modification)); } with_mod_change = new PtmSet(new_combo); } lock (r) lock (e) assign_pf_identity(e, this, with_mod_change, r, sign, best_loss != null ? best_loss : best_addition); identified.Add(e); } return(identified); }
public List <PtmSet> generate_possible_added_ptmsets(List <PtmSet> possible_peak_assignments, double deltaM, double mass_tolerance, List <ModificationWithMass> all_mods_with_mass, TheoreticalProteoform theoretical_base, string theoretical_base_sequence, int additional_ptm_penalty) { List <ModificationWithMass> known_mods = theoretical_base.ExpandedProteinList.SelectMany(p => p.OneBasedPossibleLocalizedModifications.ToList()).SelectMany(kv => kv.Value).OfType <ModificationWithMass>().ToList(); List <PtmSet> possible_ptmsets = new List <PtmSet>(); int n_terminal_degraded_aas = degraded_aas_count(theoretical_base_sequence, ptm_set, true); int c_terminal_degraded_aas = degraded_aas_count(theoretical_base_sequence, ptm_set, false); foreach (PtmSet set in possible_peak_assignments) { List <ModificationWithMass> mods_in_set = set.ptm_combination.Select(ptm => ptm.modification).ToList(); int rank_sum = additional_ptm_penalty * (set.ptm_combination.Sum(m => SaveState.lollipop.theoretical_database.unlocalized_lookup.TryGetValue(m.modification, out UnlocalizedModification x) ? x.ptm_count : 1) - 1); // penalize additional PTMs foreach (ModificationWithMass m in mods_in_set) { int mod_rank = SaveState.lollipop.theoretical_database.unlocalized_lookup.TryGetValue(m, out UnlocalizedModification u) ? u.ptm_rank : SaveState.lollipop.modification_ranks[m.monoisotopicMass]; if (m.monoisotopicMass == 0) { rank_sum += mod_rank; continue; } bool could_be_m_retention = m.modificationType == "AminoAcid" && m.motif.Motif == "M" && theoretical_base.begin == 2 && !ptm_set.ptm_combination.Select(p => p.modification).Contains(m); bool motif_matches_n_terminus = n_terminal_degraded_aas < theoretical_base_sequence.Length && m.motif.Motif == theoretical_base_sequence[n_terminal_degraded_aas].ToString(); bool motif_matches_c_terminus = c_terminal_degraded_aas < theoretical_base_sequence.Length && m.motif.Motif == theoretical_base_sequence[theoretical_base_sequence.Length - c_terminal_degraded_aas - 1].ToString(); bool cannot_be_degradation = !motif_matches_n_terminus && !motif_matches_c_terminus; if (m.modificationType == "Missing" && cannot_be_degradation || m.modificationType == "AminoAcid" && !could_be_m_retention || u != null ? u.require_proteoform_without_mod : false && set.ptm_combination.Count > 1) { rank_sum = Int32.MaxValue; break; } bool could_be_n_term_degradation = m.modificationType == "Missing" && motif_matches_n_terminus; bool could_be_c_term_degradation = m.modificationType == "Missing" && motif_matches_c_terminus; bool likely_cleavage_site = could_be_n_term_degradation && SaveState.lollipop.likely_cleavages.Contains(theoretical_base_sequence[n_terminal_degraded_aas].ToString()) || could_be_c_term_degradation && SaveState.lollipop.likely_cleavages.Contains(theoretical_base_sequence[theoretical_base_sequence.Length - c_terminal_degraded_aas - 1].ToString()); rank_sum -= Convert.ToInt32(SaveState.lollipop.theoretical_database.variableModifications.Contains(m)); // favor variable modifications over regular modifications of the same mass // In order of likelihood: // 1. First, we observe I/L/A cleavage to be the most common, // 1. "Fatty Acid" is a list of modifications prevalent in yeast or bacterial analysis, // 1. and unlocalized modifications are a subset of modifications in the intact_mods.txt list that should be included in intact analysis (handled in unlocalized modification) // 2. Second, other degradations and methionine cleavage are weighted mid-level // 3. Missed monoisotopic errors are considered, but weighted towards the bottom. This should allow missed monoisotopics with common modifications like oxidation, but not rare ones. (handled in unlocalized modification) if (likely_cleavage_site) { rank_sum += SaveState.lollipop.mod_rank_first_quartile / 2; } else if (could_be_m_retention || could_be_n_term_degradation || could_be_c_term_degradation) { rank_sum += SaveState.lollipop.mod_rank_second_quartile; } else { rank_sum += known_mods.Concat(SaveState.lollipop.theoretical_database.variableModifications).Contains(m) ? mod_rank : mod_rank + SaveState.lollipop.mod_rank_first_quartile / 2; // Penalize modifications that aren't known for this protein and push really rare ones out of the running if they're not in the protein entry } } if (rank_sum <= SaveState.lollipop.mod_rank_sum_threshold) { PtmSet adjusted_ranksum = new PtmSet(set.ptm_combination); adjusted_ranksum.ptm_rank_sum = rank_sum; possible_ptmsets.Add(adjusted_ranksum); } } return(possible_ptmsets); }
private bool assign_pf_identity(ExperimentalProteoform e, PtmSet set, int begin, int end, ProteoformRelation r, TheoreticalProteoform theoretical_base, List <Proteoform> linked_proteoform_references, bool check_ambiguous_IDs) { bool identification_assigned = false; if (!Sweet.lollipop.id_use_ppm_tolerance || Math.Abs(e.calculate_mass_error(theoretical_base, set, begin, end) * 1e6 / e.modified_mass) < Sweet.lollipop.id_ppm_tolerance) { int new_begin = begin; int new_end = end; PtmSet new_set = new PtmSet(new List <Ptm>(set.ptm_combination)); List <Ptm> remove = new List <Ptm>(); //do retention of M first foreach (var mod in new_set.ptm_combination.Where(m => m.modification.ModificationType == "AminoAcid")) { new_begin--; remove.Add(mod); } foreach (var mod in new_set.ptm_combination.Where(m => m.modification.ModificationType == "Missing")) { if (!new_set.ptm_combination.Any(m => m.modification.ModificationType == "AminoAcid") && begin >= theoretical_base.begin) { if (theoretical_base.sequence[begin - theoretical_base.begin].ToString() == mod.modification.Target.ToString()) { new_begin++; remove.Add(mod); //dont have in ptmset --> change the begin & end } } if (!remove.Contains(mod) && theoretical_base.sequence[end - theoretical_base.begin].ToString() == mod.modification.Target.ToString()) { new_end--; remove.Add(mod); } } foreach (var ptm in remove) { new_set.ptm_combination.Remove(ptm); } new_set = new PtmSet(new_set.ptm_combination); if (e.linked_proteoform_references == null) { identification_assigned = true; if (linked_proteoform_references != null) { e.linked_proteoform_references = new List <Proteoform>(linked_proteoform_references); e.linked_proteoform_references.Add(this); } else { e.linked_proteoform_references = new List <Proteoform>() { theoretical_base }; } e.relation_to_id = r; e.ptm_set = new_set; e.begin = new_begin; e.end = new_end; if (e.gene_name == null) { e.gene_name = theoretical_base.gene_name; } else { e.gene_name.gene_names.Concat(this.gene_name.gene_names); } } else { if (linked_proteoform_references != null && !linked_proteoform_references.Contains(e)) { bool different_id = e.gene_name.get_prefered_name(Lollipop.preferred_gene_label) != theoretical_base.gene_name.get_prefered_name(Lollipop.preferred_gene_label) || ExperimentalProteoform.get_sequence(e.linked_proteoform_references.First() as TheoreticalProteoform, e.begin, e.end) != ExperimentalProteoform.get_sequence(theoretical_base, new_begin, new_end) || !e.ptm_set.same_ptmset(new_set, true); List <Modification> this_known_mods = theoretical_base.ExpandedProteinList.SelectMany(p => p.OneBasedPossibleLocalizedModifications).SelectMany(kv => kv.Value).Where(v => v.MonoisotopicMass != 0).ToList(); List <Modification> previous_id_known_mods = (e.linked_proteoform_references.First() as TheoreticalProteoform).ExpandedProteinList.SelectMany(p => p.OneBasedPossibleLocalizedModifications).SelectMany(kv => kv.Value).Where(v => v.MonoisotopicMass != 0).ToList(); if (!Sweet.lollipop.topdown_theoretical_reduce_ambiguity || (theoretical_base.topdown_theoretical && !(e.linked_proteoform_references.First() as TheoreticalProteoform).topdown_theoretical)) { if (!Sweet.lollipop.annotated_PTMs_reduce_ambiguity || (new_set.ptm_combination.All(mod1 => modification_is_adduct(mod1.modification) || this_known_mods.Select(mod2 => UnlocalizedModification.LookUpId(mod2)).Contains(UnlocalizedModification.LookUpId(mod1.modification))) && !e.ptm_set.ptm_combination.All(mod1 => modification_is_adduct(mod1.modification) || previous_id_known_mods.Select(mod2 => UnlocalizedModification.LookUpId(mod2)).Contains(UnlocalizedModification.LookUpId(mod1.modification))))) { if (Sweet.lollipop.topdown_theoretical_reduce_ambiguity || Sweet.lollipop.annotated_PTMs_reduce_ambiguity) { if (Sweet.lollipop.remove_bad_connections && different_id) //&& e.relation_to_id != r) { e.relation_to_id.Identification = false; e.relation_to_id.represented_ptmset = null; } e.linked_proteoform_references = null; e.ptm_set = new PtmSet(new List <Ptm>()); e.begin = 0; e.end = 0; e.gene_name = null; e.ambiguous_identifications.Clear(); ProteoformRelation relation = null; e.relation_to_id = relation; //reassign the topdown - based ID return(this.assign_pf_identity(e, set, begin, end, r, theoretical_base, linked_proteoform_references, true)); } } } if (Sweet.lollipop.topdown_theoretical_reduce_ambiguity && (e.linked_proteoform_references.First() as TheoreticalProteoform).topdown_theoretical && !theoretical_base.topdown_theoretical) { } else if (Sweet.lollipop.annotated_PTMs_reduce_ambiguity && !new_set.ptm_combination.All(mod1 => modification_is_adduct(mod1.modification) || this_known_mods.Select(mod2 => UnlocalizedModification.LookUpId(mod2)).Contains(UnlocalizedModification.LookUpId(mod1.modification))) && e.ptm_set.ptm_combination.All(mod1 => modification_is_adduct(mod1.modification) || previous_id_known_mods.Select(mod2 => UnlocalizedModification.LookUpId(mod2)).Contains(UnlocalizedModification.LookUpId(mod1.modification)))) { } else { if (different_id) { var new_linked_proteoform_references = new List <Proteoform>(linked_proteoform_references); new_linked_proteoform_references.Add(this); AmbiguousIdentification new_id = new AmbiguousIdentification(new_begin, new_end, new_set, r, theoretical_base, new_linked_proteoform_references); lock (e.ambiguous_identifications) { if (!e.ambiguous_identifications.Any(p => p.theoretical_base.gene_name.primary == new_id.theoretical_base.gene_name.primary && ExperimentalProteoform.get_sequence(p.theoretical_base, p.begin, p.end) == ExperimentalProteoform.get_sequence(new_id.theoretical_base, new_id.begin, new_id.end) && p.ptm_set.same_ptmset(new_id.ptm_set, true))) { e.ambiguous_identifications.Add(new_id); identification_assigned = true; } } } } } } } if (check_ambiguous_IDs) { //remove bad relations if using td to reduce ambiguity if (identification_assigned) { List <AmbiguousIdentification> to_remove = new List <AmbiguousIdentification>(); List <Modification> previous_id_known_mods = (e.linked_proteoform_references.First() as TheoreticalProteoform).ExpandedProteinList.SelectMany(p => p.OneBasedPossibleLocalizedModifications).SelectMany(kv => kv.Value).Where(m => m.MonoisotopicMass != 0).ToList(); if (theoretical_base.topdown_theoretical && Sweet.lollipop.topdown_theoretical_reduce_ambiguity) { to_remove.AddRange(e.ambiguous_identifications.Where(id => !id.theoretical_base.topdown_theoretical)); } if (Sweet.lollipop.annotated_PTMs_reduce_ambiguity && e.ptm_set.ptm_combination.All(mod1 => modification_is_adduct(mod1.modification) || previous_id_known_mods.Select(mod2 => UnlocalizedModification.LookUpId(mod2)).Contains(UnlocalizedModification.LookUpId(mod1.modification)))) { foreach (var ambiguous_id in e.ambiguous_identifications) { List <Modification> ambiguous_id_known_mods = ambiguous_id.theoretical_base.ExpandedProteinList.SelectMany(p => p.OneBasedPossibleLocalizedModifications).SelectMany(kv => kv.Value).Where(m => m.MonoisotopicMass != 0).ToList(); if (ambiguous_id.ptm_set.ptm_combination.Any(mod1 => !modification_is_adduct(mod1.modification) && !ambiguous_id_known_mods.Select(mod2 => UnlocalizedModification.LookUpId(mod2)).Contains(UnlocalizedModification.LookUpId(mod1.modification)))) { to_remove.Add(ambiguous_id); } } } foreach (var x in to_remove) { if (e.ambiguous_identifications.Contains(x)) { e.ambiguous_identifications.Remove(x); if (Sweet.lollipop.remove_bad_connections) { if (e.relation_to_id != x.relation) { x.relation.Identification = false; x.relation.represented_ptmset = null; } } } } foreach (var x in e.ambiguous_identifications) { x.relation.Identification = true; } } if (this as ExperimentalProteoform != null && (this as ExperimentalProteoform).ambiguous_identifications.Count > 0) { lock ((this as ExperimentalProteoform).ambiguous_identifications) { int count = (this as ExperimentalProteoform).ambiguous_identifications.Count; PtmSet[] new_ptm_set = new PtmSet[count]; Parallel.For(0, count, i => { var id = (this as ExperimentalProteoform).ambiguous_identifications[i]; new_ptm_set[i] = determine_mod_change(e, this, id.theoretical_base, r, id.ptm_set, id.begin, id.end); }); for (int i = 0; i < count; i++) { if (new_ptm_set[i] != null) { var id = (this as ExperimentalProteoform).ambiguous_identifications[i]; if (assign_pf_identity(e, new_ptm_set[i], id.begin, id.end, r, id.theoretical_base, id.linked_proteoform_references, false)) { identification_assigned = true; } } } } } } return(identification_assigned); }
public static List <PtmSet> generate_possible_added_ptmsets(List <PtmSet> possible_peak_assignments, List <Modification> all_mods_with_mass, TheoreticalProteoform theoretical_base, int begin, int end, PtmSet ptm_set, int additional_ptm_penalty, bool final_assignment) { List <Modification> known_mods = theoretical_base.ExpandedProteinList.SelectMany(p => p.OneBasedPossibleLocalizedModifications).SelectMany(kv => kv.Value).ToList(); List <PtmSet> possible_ptmsets = new List <PtmSet>(); foreach (PtmSet set in possible_peak_assignments) { List <Modification> mods_in_set = set.ptm_combination.Select(ptm => ptm.modification).ToList(); int rank_sum = additional_ptm_penalty * (set.ptm_combination.Sum(m => Sweet.lollipop.theoretical_database.unlocalized_lookup.TryGetValue(m.modification, out UnlocalizedModification x) ? x.ptm_count : 1) - 1); // penalize additional PTMs foreach (Modification m in mods_in_set) { int mod_rank = Sweet.lollipop.theoretical_database.unlocalized_lookup.TryGetValue(m, out UnlocalizedModification u) ? u.ptm_rank : Sweet.lollipop.modification_ranks.TryGetValue(Math.Round((double)m.MonoisotopicMass, 5), out int x) ? x : Sweet.lollipop.mod_rank_sum_threshold; bool could_be_m_retention = m.ModificationType == "AminoAcid" && m.Target.ToString() == "M" && theoretical_base.begin == 2 && begin == 2 && !ptm_set.ptm_combination.Any(p => p.modification.Equals(m)); bool motif_matches_n_terminus = begin - theoretical_base.begin >= 0 && begin - theoretical_base.begin < theoretical_base.sequence.Length && m.Target.ToString() == theoretical_base.sequence[begin - theoretical_base.begin].ToString() && !mods_in_set.Any(mod => mod.ModificationType == "AminoAcid" && mod.Target.ToString() == "M"); bool motif_matches_c_terminus = end - theoretical_base.begin >= 0 && end - theoretical_base.begin < theoretical_base.sequence.Length && m.Target.ToString() == theoretical_base.sequence[end - theoretical_base.begin].ToString(); bool cannot_be_degradation = !motif_matches_n_terminus && !motif_matches_c_terminus; if ((m.ModificationType == "Missing" && cannot_be_degradation) || (m.ModificationType == "AminoAcid" && !could_be_m_retention) || ((u != null ? u.require_proteoform_without_mod : false) && set.ptm_combination.Count > 1)) { rank_sum = Int32.MaxValue; break; } bool could_be_n_term_degradation = m.ModificationType == "Missing" && motif_matches_n_terminus; bool could_be_c_term_degradation = m.ModificationType == "Missing" && motif_matches_c_terminus; //if selected, going to only allow mods in Mods folder (type "Common"), Missing, Missed Monoisotopic, known mods for that protein, or Unmodified if (Sweet.lollipop.only_assign_common_or_known_mods && final_assignment) { if (!(m.MonoisotopicMass == 0 || m.ModificationType == "Common" || could_be_m_retention || could_be_n_term_degradation || could_be_c_term_degradation || m.ModificationType == "Deconvolution Error" || known_mods.Concat(Sweet.lollipop.theoretical_database.variableModifications).Contains(m) || known_mods.Select(mod => UnlocalizedModification.LookUpId(mod)).Contains(UnlocalizedModification.LookUpId(m)))) { rank_sum = Int32.MaxValue; break; } } // In order of likelihood: // 1. First, we observe I/L/A cleavage to be the most common, other degradations and methionine cleavage are weighted mid-level // 2. Missed monoisotopic errors are considered, but weighted towards the bottom. This should allow missed monoisotopics with common modifications like oxidation, but not rare ones. (handled in unlocalized modification) if (m.MonoisotopicMass == 0) { rank_sum += mod_rank; continue; } rank_sum -= Convert.ToInt32(Sweet.lollipop.theoretical_database.variableModifications.Contains(m)); // favor variable modifications over regular modifications of the same mass if (could_be_m_retention || could_be_n_term_degradation || could_be_c_term_degradation) { rank_sum += Sweet.lollipop.mod_rank_first_quartile / 2; } else if (m.ModificationType == "Deconvolution Error") { rank_sum += Sweet.lollipop.neucode_labeled ? Sweet.lollipop.mod_rank_third_quartile : //in neucode-labeled data, fewer missed monoisotopics - don't prioritize 1; //in label-free, more missed monoisotoipcs, should prioritize (set to same priority as variable modification) rank_sum -= additional_ptm_penalty; } else { //if annotated in DB for this, just add 1? rank_sum += known_mods.Concat(Sweet.lollipop.theoretical_database.variableModifications).Select(mod => UnlocalizedModification.LookUpId(mod)).Contains(UnlocalizedModification.LookUpId(m)) ? 1 : //mod rank mod_rank + Sweet.lollipop.mod_rank_first_quartile / 2; // Penalize modifications that aren't known for this protein and push really rare ones out of the running if they're not in the protein entry } } if (rank_sum <= Sweet.lollipop.mod_rank_sum_threshold) { PtmSet adjusted_ranksum = new PtmSet(set.ptm_combination); adjusted_ranksum.ptm_rank_sum = rank_sum; possible_ptmsets.Add(adjusted_ranksum); } } return(possible_ptmsets); }
private static PtmSet determine_mod_change(ExperimentalProteoform e, Proteoform p, TheoreticalProteoform theoretical_base, ProteoformRelation r, PtmSet this_ptmset, int begin, int end) { double mass_tolerance = p.modified_mass / 1000000 * Sweet.lollipop.mass_tolerance; int sign = Math.Sign(e.modified_mass - p.modified_mass); double deltaM = Math.Sign(r.peak.DeltaMass) < 0 ? r.peak.DeltaMass : sign * r.peak .DeltaMass; // give EE relations the correct sign, but don't switch negative ET relation deltaM's List <PtmSet> possible_additions = r.peak.possiblePeakAssignments .Where(peak => Math.Abs(peak.mass - deltaM) <= 1) .ToList(); // EE relations have PtmSets around both positive and negative deltaM, so remove the ones around the opposite of the deltaM of interest PtmSet best_addition = generate_possible_added_ptmsets(possible_additions, Sweet.lollipop.theoretical_database.all_mods_with_mass, theoretical_base, begin, end, this_ptmset, 1, true) .OrderBy(x => (double)x.ptm_rank_sum + Math.Abs(x.mass - deltaM) * 10E-6) // major score: delta rank; tie breaker: deltaM, where it's always less than 1 .FirstOrDefault(); List <PtmSet> best_losses = new List <PtmSet>(); foreach (PtmSet set in r.peak.possiblePeakAssignments) //Parallel.ForEach(Sweet.lollipop.theoretical_database.all_possible_ptmsets, set => { bool within_loss_tolerance = deltaM >= -set.mass - mass_tolerance && deltaM <= -set.mass + mass_tolerance; if (within_loss_tolerance) { List <Modification> these_mods = this_ptmset.ptm_combination.Select(ptm => ptm.modification).ToList(); List <Modification> those_mods = set.ptm_combination.Select(ptm => ptm.modification).ToList(); // all must be in the current set to remove them bool can_be_removed = those_mods.All(m1 => these_mods.Count(m2 => UnlocalizedModification.LookUpId(m2) == UnlocalizedModification.LookUpId(m1)) >= those_mods.Count(m2 => UnlocalizedModification.LookUpId(m2) == UnlocalizedModification.LookUpId(m1))); lock (best_losses) { if (can_be_removed && within_loss_tolerance) { best_losses.Add(set); } } } } //); PtmSet best_loss = best_losses.OrderBy(s => Math.Abs(deltaM - (-s.mass))).FirstOrDefault(); if (best_addition == null && best_loss == null) { return(null); } // Make the new ptmset with ptms removed or added PtmSet with_mod_change = null; if (best_loss == null) { with_mod_change = new PtmSet(new List <Ptm>(this_ptmset.ptm_combination .Concat(best_addition.ptm_combination).Where(ptm => ptm.modification.MonoisotopicMass != 0) .ToList())); } else { List <Ptm> new_combo = new List <Ptm>(this_ptmset.ptm_combination); foreach (Ptm ptm in best_loss.ptm_combination) { new_combo.Remove(new_combo.FirstOrDefault(asdf => UnlocalizedModification.LookUpId(asdf.modification) == UnlocalizedModification.LookUpId(ptm.modification))); } with_mod_change = new PtmSet(new_combo); } if (r.represented_ptmset == null) { r.represented_ptmset = best_loss == null ? best_addition : best_loss; //if (r.RelationType == ProteoformComparison.ExperimentalExperimental) //{ // r.DeltaMass *= sign; //} } return(with_mod_change); }
private void assign_pf_identity(ExperimentalProteoform e, PtmSet set, ProteoformRelation r, TheoreticalProteoform theoretical_base) { if (e.linked_proteoform_references == null) { e.linked_proteoform_references = new List <Proteoform>(this.linked_proteoform_references); e.linked_proteoform_references.Add(this); e.ptm_set = set; e.begin = this.begin; e.end = this.end; List <Ptm> remove = new List <Ptm>(); //do retention of M first foreach (var mod in set.ptm_combination.Where(m => m.modification.ModificationType == "AminoAcid")) { e.begin--; remove.Add(mod); } foreach (var mod in set.ptm_combination.Where(m => m.modification.ModificationType == "Missing")) { if (theoretical_base.sequence[this.begin - theoretical_base.begin].ToString() == mod.modification.Target.ToString()) { e.begin++; remove.Add(mod); //dont have in ptmset --> change the begin & end } else if (theoretical_base.sequence[this.end - this.begin].ToString() == mod.modification.Target.ToString()) { e.end--; remove.Add(mod); } } foreach (var ptm in remove) { e.ptm_set.ptm_combination.Remove(ptm); } e.ptm_set = new PtmSet(e.ptm_set.ptm_combination); if (e.gene_name == null) { e.gene_name = this.gene_name; } else if (!e.topdown_id) { e.gene_name.gene_names.Concat(this.gene_name.gene_names); } } else { //check if assign int begin = this.begin; int end = this.end; PtmSet ptm_set = set; List <Ptm> remove = new List <Ptm>(); //do retention of M first foreach (var mod in set.ptm_combination.Where(m => m.modification.ModificationType == "AminoAcid")) { begin--; remove.Add(mod); } foreach (var mod in set.ptm_combination.Where(m => m.modification.ModificationType == "Missing")) { if (theoretical_base.sequence[this.begin - theoretical_base.begin].ToString() == mod.modification.Target.ToString()) { begin++; remove.Add(mod); //dont have in ptmset --> change the begin & end } else if (theoretical_base.sequence[this.end - this.begin].ToString() == mod.modification.Target.ToString()) { end--; remove.Add(mod); } } foreach (var ptm in remove) { ptm_set.ptm_combination.Remove(ptm); } ptm_set = new PtmSet(ptm_set.ptm_combination); if (e.gene_name.get_prefered_name(Lollipop.preferred_gene_label) != this.gene_name.get_prefered_name(Lollipop.preferred_gene_label) || e.begin != begin || e.end != end || !e.ptm_set.same_ptmset(ptm_set, true)) { e.ambiguous = true; Proteoform linked_proteoform_reference = this.linked_proteoform_references == null || this.linked_proteoform_references.Count == 0 ? this : this.linked_proteoform_references.First(); Tuple <Proteoform, int, int, PtmSet> new_id = new Tuple <Proteoform, int, int, PtmSet>(linked_proteoform_reference, begin, end, ptm_set); lock (e.ambiguous_identifications) { if (!e.ambiguous_identifications.Any(p => p.Item1.gene_name.get_prefered_name(Lollipop.preferred_gene_label) == new_id.Item1.gene_name.get_prefered_name(Lollipop.preferred_gene_label) && p.Item2 == new_id.Item2 && p.Item3 == new_id.Item3 && p.Item4.same_ptmset(new_id.Item4, true))) { e.ambiguous_identifications.Add(new_id); } } } } if (this as ExperimentalProteoform != null && (this as ExperimentalProteoform).ambiguous) { foreach (var id in this.ambiguous_identifications) { TheoreticalProteoform id_theoretical_base = id.Item1 as TheoreticalProteoform; int begin = id.Item2; int end = id.Item3; var remove = new List <Ptm>(); var ptm_set = determine_mod_change(e, this, id_theoretical_base, r, id.Item4); if (ptm_set == null) { continue; } //do retention of M first foreach (var mod in ptm_set.ptm_combination.Where(m => m.modification.ModificationType == "AminoAcid")) { begin--; remove.Add(mod); } foreach (var mod in ptm_set.ptm_combination.Where(m => m.modification.ModificationType == "Missing")) { if (id_theoretical_base.sequence[id.Item2 - id.Item1.begin].ToString() == mod.modification.Target.ToString()) { begin++; remove.Add(mod); //dont have in ptmset --> change the begin & end } else if (id_theoretical_base.sequence[id.Item3 - id.Item2].ToString() == mod.modification.Target.ToString()) { end--; remove.Add(mod); } } foreach (var ptm in remove) { ptm_set.ptm_combination.Remove(ptm); } ptm_set = new PtmSet(ptm_set.ptm_combination); lock (e.ambiguous_identifications) { var new_id = new Tuple <Proteoform, int, int, PtmSet>(id.Item1, begin, end, ptm_set); if ((e.gene_name.get_prefered_name(Lollipop.preferred_gene_label) != new_id.Item1.gene_name.get_prefered_name(Lollipop.preferred_gene_label) || e.begin != new_id.Item2 || e.end != new_id.Item3 || !e.ptm_set.same_ptmset(new_id.Item4, true)) && !e.ambiguous_identifications.Any(p => p.Item1.gene_name.get_prefered_name(Lollipop.preferred_gene_label) == new_id.Item1.gene_name.get_prefered_name(Lollipop.preferred_gene_label) && p.Item2 == new_id.Item2 && p.Item3 == new_id.Item3 && p.Item4.same_ptmset(new_id.Item4, true))) { e.ambiguous_identifications.Add(new_id); e.ambiguous = true; } } } } e.uniprot_mods = ""; foreach (string mod in e.ptm_set.ptm_combination.Concat(e.ambiguous_identifications.SelectMany(i => i.Item4.ptm_combination)).Where(ptm => ptm.modification.ModificationType != "Deconvolution Error").Select(ptm => UnlocalizedModification.LookUpId(ptm.modification)).ToList().Distinct().OrderBy(m => m)) { // positions with mod List <int> theo_ptms = theoretical_base.ExpandedProteinList.First() .OneBasedPossibleLocalizedModifications .Where(p => p.Key >= e.begin && p.Key <= e.end && p.Value.Select(m => UnlocalizedModification.LookUpId(m)).Contains(mod)) .Select(m => m.Key).ToList(); if (theo_ptms.Count > 0) { e.uniprot_mods += mod + " @ " + string.Join(", ", theo_ptms) + "; "; } if (e.ptm_set.ptm_combination.Select(ptm => UnlocalizedModification.LookUpId(ptm.modification)) .Count(m => m == mod) > theo_ptms.Count || e.ambiguous_identifications.Any(i => i.Item4.ptm_combination.Select(ptm => UnlocalizedModification.LookUpId(ptm.modification)) .Count(m => m == mod) > theo_ptms.Count)) { e.novel_mods = true; } } //else if (!e.topdown_id && e.gene_name.get_prefered_name(Lollipop.preferred_gene_label) != this.gene_name.get_prefered_name(Lollipop.preferred_gene_label) // && e.linked_proteoform_references.Count == this.linked_proteoform_references.Count + 1) //{ // e.ambiguous = true; //} }
public void EnterTheoreticalProteformFamily(string seq, ProteinWithGoTerms prot, IDictionary <int, List <Modification> > modifications, string accession, List <TheoreticalProteoform> theoretical_proteoforms, int decoy_number, IEnumerable <Modification> variableModifications) { List <TheoreticalProteoform> new_theoreticals = new List <TheoreticalProteoform>(); if (seq.Length > 3000 || seq.Any(s => !aaIsotopeMassList.ContainsKey(s))) { return; } //Calculate the properties of this sequence double unmodified_mass = TheoreticalProteoform.CalculateProteoformMass(seq, new List <Ptm>()); int lysine_count = seq.Split('K').Length - 1; bool check_contaminants = theoretical_proteins.Any(item => item.Key.ContaminantDB); //Figure out the possible ptm sets Dictionary <int, List <Modification> > possibleLocalizedMods = modifications.ToDictionary(kv => kv.Key, kv => new List <Modification>(kv.Value)); foreach (Modification m in variableModifications) { for (int i = 1; i <= prot.BaseSequence.Length; i++) { if (prot.BaseSequence[i - 1].ToString() == m.Target.ToString()) { if (!possibleLocalizedMods.TryGetValue(i, out List <Modification> a)) { possibleLocalizedMods.Add(i, new List <Modification> { m }); } else { a.Add(m); } } } } int ptm_set_counter = 1; //if top-down protein sequence, only add PTMs from that top-down proteoforms (will happen in add_topdown_theoreticals method) if (!prot.topdown_protein) { List <PtmSet> unique_ptm_groups = PtmCombos.get_combinations(possibleLocalizedMods, Sweet.lollipop.max_ptms, Sweet.lollipop.modification_ranks, Sweet.lollipop.mod_rank_first_quartile / 2, limit_triples_and_greater); //Enumerate the ptm combinations with _P# to distinguish from the counts in ProteinSequenceGroups (_#G) and TheoreticalPfGps (_#T) foreach (PtmSet ptm_set in unique_ptm_groups) { TheoreticalProteoform t = new TheoreticalProteoform( accession + "_P" + ptm_set_counter.ToString(), prot.FullDescription + "_P" + ptm_set_counter.ToString() + (decoy_number < 0 ? "" : "_DECOY_" + decoy_number.ToString()), seq, (prot as ProteinSequenceGroup != null ? (prot as ProteinSequenceGroup).proteinWithGoTermList.ToArray() : new ProteinWithGoTerms[] { prot }), unmodified_mass, lysine_count, ptm_set, decoy_number < 0, check_contaminants, theoretical_proteins); t.topdown_theoretical = prot.topdown_protein; new_theoreticals.Add(t); ptm_set_counter++; } } add_topdown_theoreticals(prot, seq, accession, unmodified_mass, decoy_number, lysine_count, new_theoreticals, ptm_set_counter, Sweet.lollipop.modification_ranks, Sweet.lollipop.mod_rank_first_quartile / 2); lock (theoretical_proteoforms) theoretical_proteoforms.AddRange(new_theoreticals); }
public ProteoformRelation(Proteoform pf1, Proteoform pf2, ProteoformComparison relation_type, double delta_mass, string current_directory) { connected_proteoforms[0] = pf1; connected_proteoforms[1] = pf2; RelationType = relation_type; DeltaMass = delta_mass; InstanceId = instanceCounter; lock (Sweet.lollipop) instanceCounter += 1; //Not thread safe if (CH2 == null || HPO3 == null) { CH2 = ChemicalFormula.ParseFormula("C1 H2"); HPO3 = ChemicalFormula.ParseFormula("H1 O3 P1"); } if (Sweet.lollipop.neucode_labeled) { lysine_count = pf1.lysine_count; } List <PtmSet> candidate_sets = new List <PtmSet>(); if (Sweet.lollipop.et_use_notch && (relation_type == ProteoformComparison.ExperimentalTheoretical || relation_type == ProteoformComparison.ExperimentalDecoy)) { if (Sweet.lollipop.et_use_notch && !Sweet.lollipop.et_notch_ppm) { double mass = delta_mass - Sweet.lollipop.notch_tolerance_et; while (mass <= delta_mass + Sweet.lollipop.notch_tolerance_et) { Sweet.lollipop.theoretical_database.possible_ptmset_dictionary_notches.TryGetValue( Math.Round(mass, 1), out List <PtmSet> candidates); if (candidates != null) { candidate_sets.AddRange(candidates); } mass += 0.1; } candidate_sets = candidate_sets.Distinct().ToList(); } else { Sweet.lollipop.theoretical_database.possible_ptmset_dictionary_notches.TryGetValue(Math.Round(delta_mass, 1), out candidate_sets); } if (candidate_sets != null) { candidate_sets = candidate_sets.Where(s => Sweet.lollipop.et_notch_ppm ? Math.Abs(s.mass - delta_mass) * 1e6 / pf1.modified_mass < Sweet.lollipop.notch_tolerance_et : Math.Abs(s.mass - delta_mass) < Sweet.lollipop.notch_tolerance_et).ToList(); candidate_ptmset = candidate_sets.OrderBy(s => s.ptm_rank_sum).FirstOrDefault(); } } else if (Sweet.lollipop.ee_use_notch && (relation_type == ProteoformComparison.ExperimentalExperimental || relation_type == ProteoformComparison.ExperimentalFalse)) { if (Sweet.lollipop.ee_use_notch && !Sweet.lollipop.ee_notch_ppm) { double mass = delta_mass - Sweet.lollipop.notch_tolerance_ee; while (mass <= delta_mass + Sweet.lollipop.notch_tolerance_ee) { Sweet.lollipop.theoretical_database.possible_ptmset_dictionary_notches.TryGetValue( Math.Round(mass, 1), out List <PtmSet> candidates); if (candidates != null) { candidate_sets.AddRange(candidates); } mass += 0.1; } candidate_sets = candidate_sets.Distinct().ToList(); } else { Sweet.lollipop.theoretical_database.possible_ptmset_dictionary_notches.TryGetValue(Math.Round(delta_mass, 1), out candidate_sets); } if (candidate_sets != null) { candidate_sets = candidate_sets.Where(s => Sweet.lollipop.ee_notch_ppm ? Math.Abs(s.mass - delta_mass) * 1e6 / pf1.modified_mass < Sweet.lollipop.notch_tolerance_ee : Math.Abs(s.mass - delta_mass) < Sweet.lollipop.notch_tolerance_ee).ToList(); candidate_ptmset = candidate_sets.OrderBy(s => s.ptm_rank_sum).FirstOrDefault(); } } else if (relation_type == ProteoformComparison.ExperimentalTheoretical || relation_type == ProteoformComparison.ExperimentalDecoy) { if (Sweet.lollipop.peak_width_base_et > 0.09) { double mass = delta_mass - Sweet.lollipop.peak_width_base_et; while (mass <= delta_mass + Sweet.lollipop.peak_width_base_et) { Sweet.lollipop.theoretical_database.possible_ptmset_dictionary.TryGetValue( Math.Round(mass, 1), out List <PtmSet> candidates); if (candidates != null) { candidate_sets.AddRange(candidates); } mass += 0.1; } candidate_sets = candidate_sets.Distinct().ToList(); } else { Sweet.lollipop.theoretical_database.possible_ptmset_dictionary.TryGetValue( Math.Round(delta_mass, 1), out candidate_sets); } if (pf2 as TheoreticalProteoform != null && candidate_sets != null && candidate_sets.Count > 0) { List <PtmSet> narrower_range_of_candidates = new List <PtmSet>(); if (Sweet.lollipop.et_use_notch) { narrower_range_of_candidates = candidate_sets; } else { narrower_range_of_candidates = candidate_sets .Where(s => Math.Abs(s.mass - delta_mass) < Sweet.lollipop.peak_width_base_et).ToList(); } TheoreticalProteoform t = pf2 as TheoreticalProteoform; candidate_ptmset = Proteoform.generate_possible_added_ptmsets(narrower_range_of_candidates, Sweet.lollipop.theoretical_database.all_mods_with_mass, t, pf2.begin, pf2.end, pf2.ptm_set, Sweet.lollipop.mod_rank_first_quartile, false).OrderBy(x => x.ptm_rank_sum + Math.Abs(Math.Abs(x.mass) - Math.Abs(delta_mass)) * 10E-6) // major score: delta rank; tie breaker: deltaM, where it's always less than 1 .FirstOrDefault(); } } // Start the model (0 Da) at the mass defect of CH2 or HPO3 itself, allowing the peak width tolerance on either side double half_peak_width = RelationType == ProteoformComparison.ExperimentalTheoretical || RelationType == ProteoformComparison.ExperimentalDecoy ? Sweet.lollipop.peak_width_base_et / 2 : Sweet.lollipop.peak_width_base_ee / 2; double low_decimal_bound = half_peak_width + ((CH2.MonoisotopicMass - Math.Truncate(CH2.MonoisotopicMass)) / CH2.MonoisotopicMass) * (Math.Abs(delta_mass) <= CH2.MonoisotopicMass ? CH2.MonoisotopicMass : Math.Abs(delta_mass)); double high_decimal_bound = 1 - half_peak_width + ((HPO3.MonoisotopicMass - Math.Ceiling(HPO3.MonoisotopicMass)) / HPO3.MonoisotopicMass) * (Math.Abs(delta_mass) <= HPO3.MonoisotopicMass ? HPO3.MonoisotopicMass : Math.Abs(delta_mass)); double delta_mass_decimal = Math.Abs(delta_mass - Math.Truncate(delta_mass)); outside_no_mans_land = delta_mass_decimal <= low_decimal_bound || delta_mass_decimal >= high_decimal_bound || high_decimal_bound <= low_decimal_bound; if (Sweet.lollipop.et_use_notch && (relation_type == ProteoformComparison.ExperimentalTheoretical || relation_type == ProteoformComparison.ExperimentalDecoy)) { outside_no_mans_land = true; } if (Sweet.lollipop.ee_use_notch && (relation_type == ProteoformComparison.ExperimentalExperimental || relation_type == ProteoformComparison.ExperimentalFalse)) { outside_no_mans_land = true; } }
public void identify_experimentals() { HashSet <ExperimentalProteoform> identified_experimentals = new HashSet <ExperimentalProteoform>(); if (Sweet.lollipop.identify_from_td_nodes) { foreach (TopDownProteoform topdown in experimental_proteoforms.Where(e => e.topdown_id)) { Sweet.lollipop.theoretical_database .theoreticals_by_accession[Sweet.lollipop.target_proteoform_community.community_number] .TryGetValue(topdown.accession.Split('_')[0].Split('-')[0], out var t); if (t != null && t.Count > 0) { TheoreticalProteoform theoretical = new TheoreticalProteoform(topdown.accession, topdown.name, topdown.sequence, t.First().ExpandedProteinList, topdown.modified_mass, topdown.lysine_count, topdown.topdown_ptm_set, true, false, null); theoretical.topdown_theoretical = true; theoretical.new_topdown_proteoform = true; theoretical.begin = topdown.topdown_begin; theoretical.end = topdown.topdown_end; foreach (ExperimentalProteoform e in topdown.identify_connected_experimentals(theoretical, topdown.topdown_begin, topdown.topdown_end, new PtmSet(topdown.topdown_ptm_set.ptm_combination), null)) { identified_experimentals.Add(e); } } } } foreach (TheoreticalProteoform t in theoretical_proteoforms.OrderBy(t => t.topdown_theoretical)) { lock (identified_experimentals) foreach (ExperimentalProteoform e in t.identify_connected_experimentals(t, t.begin, t.end, t.ptm_set, t.linked_proteoform_references)) { identified_experimentals.Add(e); } } //Continue looking for new experimental identifications until no more remain to be identified List <ExperimentalProteoform> newly_identified_experimentals = new List <ExperimentalProteoform>(identified_experimentals).OrderBy(p => p.relationships.Count(r => r.candidate_ptmset != null) > 0 ? p.relationships.Where(r => r.candidate_ptmset != null).Min(r => Math.Abs(r.DeltaMass - r.candidate_ptmset.mass)) : 1e6).ThenBy(p => p.modified_mass).ToList(); int last_identified_count = identified_experimentals.Count - 1; while (newly_identified_experimentals.Count > 0) //&& identified_experimentals.Count > last_identified_count) { last_identified_count = identified_experimentals.Count; HashSet <ExperimentalProteoform> tmp_new_experimentals = new HashSet <ExperimentalProteoform>(); foreach (ExperimentalProteoform id_experimental in newly_identified_experimentals) { { lock (identified_experimentals) lock (tmp_new_experimentals) foreach (ExperimentalProteoform new_e in id_experimental.identify_connected_experimentals(id_experimental.linked_proteoform_references.First() as TheoreticalProteoform, id_experimental.begin, id_experimental.end, id_experimental.ptm_set, id_experimental.linked_proteoform_references)) { identified_experimentals.Add(new_e); tmp_new_experimentals.Add(new_e); } } } newly_identified_experimentals = new List <ExperimentalProteoform>(tmp_new_experimentals); } List <string> topdown_ids = Sweet.lollipop.topdown_proteoforms .Select(p => p.accession.Split('_')[0].Split('-')[0] + "_" + p.sequence + "_" + string.Join(", ", p.topdown_ptm_set.ptm_combination.Where(m => m.modification.ModificationType != "Deconvolution Error").Select(ptm => UnlocalizedModification.LookUpId(ptm.modification)).OrderBy(m => m))).ToList(); //determine identified experimentals that are adducts //checks if any experimentals have same mods as e's ptmset, except e has additional adduct only mods. Parallel.ForEach(experimental_proteoforms, e => { e.adduct = e.linked_proteoform_references != null && e.ptm_set.ptm_combination.Any(m => Proteoform.modification_is_adduct(m.modification)) && experimental_proteoforms.Any(l => l.linked_proteoform_references != null && l.gene_name.get_prefered_name(Lollipop.preferred_gene_label) == e.gene_name.get_prefered_name(Lollipop.preferred_gene_label) && l.ptm_set.ptm_combination.Count < e.ptm_set.ptm_combination.Count && e.ptm_set.ptm_combination.Where(m => l.ptm_set.ptm_combination.Count(p => UnlocalizedModification.LookUpId(p.modification) == UnlocalizedModification.LookUpId(m.modification)) != e.ptm_set.ptm_combination.Count(p => UnlocalizedModification.LookUpId(p.modification) == UnlocalizedModification.LookUpId(m.modification))) .Count(p => !Proteoform.modification_is_adduct(p.modification)) == 0 ); if (e as TopDownProteoform != null) { (e as TopDownProteoform).set_correct_id(); } if (e.linked_proteoform_references != null) { var mods = e.ptm_set.ptm_combination.Where(p => !Proteoform.modification_is_adduct(p.modification)) .Select(ptm => UnlocalizedModification.LookUpId(ptm.modification)).ToList().Distinct().OrderBy(m => m).ToList(); e.uniprot_mods = ""; string add = ""; foreach (string mod in mods) { // positions with mod List <int> theo_ptms = (e.linked_proteoform_references.First() as TheoreticalProteoform).ExpandedProteinList.SelectMany(p => p .OneBasedPossibleLocalizedModifications) .Where(p => p.Key >= e.begin && p.Key <= e.end && p.Value.Select(m => UnlocalizedModification.LookUpId(m)).Contains(mod)) .Select(m => m.Key).ToList(); if (theo_ptms.Count > 0) { add += mod + " @ " + string.Join(", ", theo_ptms) + "; "; } if (e.ptm_set.ptm_combination.Where(ptm => ptm.modification.ModificationType != "Deconvolution Error" && !Proteoform.modification_is_adduct(ptm.modification)).Select(ptm => UnlocalizedModification.LookUpId(ptm.modification)) .Count(m => m == mod) > theo_ptms.Count) { e.novel_mods = true; } } e.uniprot_mods += add; if (add.Length == 0) { e.uniprot_mods += "N/A"; } foreach (var ambig_id in e.ambiguous_identifications) { var ambig_mods = ambig_id.ptm_set.ptm_combination.Where(p => !Proteoform.modification_is_adduct(p.modification)) .Select(ptm => UnlocalizedModification.LookUpId(ptm.modification)).ToList().Distinct().OrderBy(m => m).ToList(); e.uniprot_mods += " | "; add = ""; foreach (var mod in ambig_mods) { // positions with mod List <int> theo_ptms = ambig_id.theoretical_base.ExpandedProteinList.SelectMany(p => p .OneBasedPossibleLocalizedModifications) .Where(p => p.Key >= ambig_id.begin && p.Key <= ambig_id.end && p.Value.Select(m => UnlocalizedModification.LookUpId(m)).Contains(mod)) .Select(m => m.Key).ToList(); if (theo_ptms.Count > 0) { add += mod + " @ " + string.Join(", ", theo_ptms) + "; "; } if (ambig_id.ptm_set.ptm_combination.Where(ptm => ptm.modification.ModificationType != "Deconvolution Error" && !Proteoform.modification_is_adduct(ptm.modification)).Select(ptm => UnlocalizedModification.LookUpId(ptm.modification)) .Count(m => m == mod) > theo_ptms.Count) { e.novel_mods = true; } } e.uniprot_mods += add; if (add.Length == 0) { e.uniprot_mods += "N/A"; } } } //determine level # e.proteoform_level_description = ""; if (e.linked_proteoform_references == null) { e.proteoform_level = 5; e.proteoform_level_description = "Unidentified"; } else if (e.ambiguous_identifications.Count == 0) { if (e.ptm_set.ptm_combination.Count == 0) { e.proteoform_level = 1; } else { e.proteoform_level = 2; e.proteoform_level_description += "PTM localization ambiguity; "; } //check if accessions had been grouped in constructing the theoretical database if ((e.linked_proteoform_references.First() as TheoreticalProteoform).ExpandedProteinList.SelectMany(p => p.AccessionList).Select(a => a.Split('_')[0]).Distinct().Count() > 1) { e.proteoform_level += 1; e.proteoform_level_description += "Gene ambiguity; "; } } else { var unique_accessions = new List <string>() { e.linked_proteoform_references.First().accession.Split('_')[0].Split('-')[0] }.Concat(e.ambiguous_identifications.Select(a => a.theoretical_base.accession.Split('_')[0].Split('-')[0])).Distinct(); var unique_sequences = new List <string>() { ExperimentalProteoform.get_sequence(e.linked_proteoform_references.First() as TheoreticalProteoform, e.begin, e.end) }. Concat(e.ambiguous_identifications.Select(a => ExperimentalProteoform.get_sequence(a.theoretical_base, a.begin, a.end))).Distinct(); var unique_PTMs = new List <string>() { string.Join(", ", e.ptm_set.ptm_combination.Where(m => m.modification.ModificationType != "Deconvolution Error").Select(ptm => UnlocalizedModification.LookUpId(ptm.modification)).OrderBy(m => m)) }.Concat(e.ambiguous_identifications.Select(a => string.Join(", ", a.ptm_set.ptm_combination.Where(m => m.modification.ModificationType != "Deconvolution Error").Select(ptm => UnlocalizedModification.LookUpId(ptm.modification))))).Distinct(); int gene_ambiguity = unique_accessions.Count() > 1 ? 1 : 0; //check if accessions had been grouped in constructing the theoretical database if ((e.linked_proteoform_references.First() as TheoreticalProteoform).ExpandedProteinList.SelectMany(p => p.AccessionList).Select(a => a.Split('_')[0]).Distinct().Count() > 1) { gene_ambiguity = 1; } int sequence_ambiguity = unique_sequences.Count() > 1 ? 1 : 0; int PTM_ambiguity = unique_PTMs.Count() > 1 ? 1 : 0; int PTM_location = e.ptm_set.ptm_combination.Count(m => m.modification.ModificationType != "Deconvolution Error") > 0 || e.ambiguous_identifications.Any(a => a.ptm_set.ptm_combination.Count(m => m.modification.ModificationType != "Deconvolution Error") > 0) ? 1 : 0; e.proteoform_level = 1 + gene_ambiguity + sequence_ambiguity + PTM_ambiguity + PTM_location; if (gene_ambiguity > 0) { e.proteoform_level_description += "Gene ambiguity; "; } if (sequence_ambiguity > 0) { e.proteoform_level_description += "Sequence ambiguity; "; } if (PTM_ambiguity > 0) { e.proteoform_level_description += "PTM identity ambiguity; "; } if (PTM_location > 0) { e.proteoform_level_description += "PTM localization ambiguity; "; } } if (e.proteoform_level == 1) { e.proteoform_level_description = "Unambiguous"; } //determine if new intact-mass ID e.new_intact_mass_id = false; if (!e.topdown_id && e.linked_proteoform_references != null && e.ambiguous_identifications.Count == 0) { string this_id = string.Join(",", (e.linked_proteoform_references.First() as TheoreticalProteoform).ExpandedProteinList.SelectMany(p => p.AccessionList.Select(a => a.Split('_')[0])).Distinct()) + "_" + ExperimentalProteoform.get_sequence(e.linked_proteoform_references.First() as TheoreticalProteoform, e.begin, e.end) + "_" + string.Join(", ", e.ptm_set.ptm_combination.Where(m => m.modification.ModificationType != "Deconvolution Error").Select(ptm => UnlocalizedModification.LookUpId(ptm.modification)).OrderBy(m => m)); if (!topdown_ids.Any(t => this_id.Split('_')[0].Split(',').Contains(t.Split('_')[0]) && this_id.Split('_')[1] == t.Split('_')[1] && this_id.Split('_')[2] == t.Split('_')[2])) { e.new_intact_mass_id = true; } } }); if (Sweet.lollipop.remove_bad_connections) { if (theoretical_proteoforms.Count > 0 || (Sweet.lollipop.identify_from_td_nodes && experimental_proteoforms.Count(e => e.topdown_id) > 0)) { Parallel.ForEach(relations, r => { r.Accepted = r.Identification; }); } } }