public SrmSettingsDiff(SrmSettingsDiff diff, SrmSettingsDiff diffUnion) { DiffPeptides = diff.DiffPeptides || diffUnion.DiffPeptides; DiffPeptideProps = diff.DiffPeptideProps || diffUnion.DiffPeptideProps; DiffTransitionGroups = diff.DiffTransitionGroups || diffUnion.DiffTransitionGroups; DiffTransitionGroupProps = diff.DiffTransitionGroupProps || diffUnion.DiffTransitionGroupProps; DiffTransitions = diff.DiffTransitions || diffUnion.DiffTransitions; DiffTransitionProps = diff.DiffTransitionProps || diffUnion.DiffTransitionProps; DiffResults = diff.DiffResults || diffUnion.DiffResults; DiffResultsAll = diff.DiffResultsAll || diffUnion.DiffResultsAll; SettingsOld = diff.SettingsOld; }
public PeptideDocNode GetModifiedNode(LibKey key, string seqUnmod, SrmSettings settings, SrmSettingsDiff diff) { if (string.IsNullOrEmpty(seqUnmod)) return null; var peptide = new Peptide(null, seqUnmod, null, null, settings.PeptideSettings.Enzyme.CountCleavagePoints(seqUnmod)); // First try and create the match from the settings created to match the library explorer. Settings = HasMatches ? settings.ChangePeptideModifications(mods => MatcherPepMods) : settings; TransitionGroupDocNode nodeGroup; var nodePep = CreateDocNodeFromSettings(key.Sequence, peptide, diff, out nodeGroup); if (nodePep != null) { if (diff == null) { nodePep = (PeptideDocNode)nodePep.ChangeAutoManageChildren(false); } else { // Keep only the matching transition group, so that modifications // will be highlighted differently for light and heavy forms. // Only performed when getting peptides for display in the explorer. nodePep = (PeptideDocNode)nodePep.ChangeChildrenChecked( new DocNode[] { nodeGroup }); } return nodePep; } else if (Matches == null) return null; bool hasHeavy; // Create explicit mods from the found matches. nodePep = CreateDocNodeFromMatches(new PeptideDocNode(peptide), EnumerateSequenceInfos(key.Key, true), false, out hasHeavy); if (nodePep == null) return null; // Call change settings with the matched modification settings to enumerate the children. nodePep = nodePep.ChangeSettings(settings.ChangePeptideModifications(mods => !HasMatches ? settings.PeptideSettings.Modifications : MatcherPepMods), diff ?? SrmSettingsDiff.ALL); if (nodePep.Children.Count == 0) return null; // Select the correct child, only for use with the library explorer. if (diff != null && nodePep.Children.Count > 1) { nodePep = (PeptideDocNode) nodePep.ChangeChildrenChecked(new List<DocNode> { nodePep.Children[hasHeavy ? 1 : 0] }); } if (diff == null) { nodePep = (PeptideDocNode)nodePep.ChangeAutoManageChildren(false); } return nodePep; }
public PeptideDocNode CreateDocNodeFromSettings(string seq, Peptide peptide, SrmSettingsDiff diff, out TransitionGroupDocNode nodeGroupMatched) { seq = Transition.StripChargeIndicators(seq, TransitionGroup.MIN_PRECURSOR_CHARGE, TransitionGroup.MAX_PRECURSOR_CHARGE); if (peptide == null) { string seqUnmod = FastaSequence.StripModifications(seq); try { peptide = new Peptide(null, seqUnmod, null, null, Settings.PeptideSettings.Enzyme.CountCleavagePoints(seqUnmod)); } catch (InvalidDataException) { nodeGroupMatched = null; return null; } } // Use the number of modifications as the maximum, if it is less than the current // settings to keep from over enumerating, which can be slow. var filter = new MaxModFilter(Math.Min(seq.Count(c => c == '[' || c == '('), Settings.PeptideSettings.Modifications.MaxVariableMods)); foreach (var nodePep in peptide.CreateDocNodes(Settings, filter)) { var nodePepMod = CreateDocNodeFromSettings(seq, nodePep, diff, out nodeGroupMatched); if (nodePepMod != null) return nodePepMod; } nodeGroupMatched = null; return null; }
private PeptideDocNode CreateDocNodeFromSettings(string seq, PeptideDocNode nodePep, SrmSettingsDiff diff, out TransitionGroupDocNode nodeGroupMatched) { PeptideDocNode nodePepMod = nodePep.ChangeSettings(Settings, diff ?? SrmSettingsDiff.ALL, false); TransitionGroupDocNode nodeGroupMatchedFound; if (IsMatch(seq, nodePepMod, out nodeGroupMatchedFound)) { nodeGroupMatched = nodeGroupMatchedFound; return nodePepMod; } nodeGroupMatched = null; return null; }
public ViewLibraryPepInfo AssociateMatchingPeptide(ViewLibraryPepInfo pepInfo, int charge, SrmSettingsDiff settingsDiff) { var key = pepInfo.Key; var settings = _chargeSettingsMap[charge]; // Change current document settings to match the current library and change the charge filter to // match the current peptide. if (settings == null) { settings = _document.Settings; var rankId = settings.PeptideSettings.Libraries.RankId; if (rankId != null && !_selectedSpec.PeptideRankIds.Contains(rankId)) settings = settings.ChangePeptideLibraries(lib => lib.ChangeRankId(null)); settings = settings.ChangePeptideLibraries( lib => lib.ChangeLibraries(new[] { _selectedSpec }, new[] { _selectedLibrary }) .ChangePick(PeptidePick.library)) .ChangeTransitionFilter( filter => filter.ChangePrecursorCharges(new[] { charge }).ChangeAutoSelect(true)) .ChangeMeasuredResults(null); _chargeSettingsMap[charge] = settings; } var nodePep = _matcher.GetModifiedNode(key, pepInfo.GetAASequence(_lookupPool), settings, settingsDiff); if (nodePep != null) { pepInfo.PeptideNode = nodePep; } return pepInfo; }
public PeptideGroupDocNode ChangeSettings(SrmSettings settingsNew, SrmSettingsDiff diff) { if (diff.Monitor != null) diff.Monitor.ProcessGroup(this); if (diff.DiffPeptides && settingsNew.PeptideSettings.Filter.AutoSelect && AutoManageChildren) { IList<DocNode> childrenNew = new List<DocNode>(); int countPeptides = 0; int countIons = 0; Dictionary<int, DocNode> mapIndexToChild = CreateGlobalIndexToChildMap(); Dictionary<PeptideModKey, DocNode> mapIdToChild = CreatePeptideModToChildMap(); foreach(PeptideDocNode nodePep in GetPeptideNodes(settingsNew, true)) { PeptideDocNode nodePepResult = nodePep; SrmSettingsDiff diffNode = SrmSettingsDiff.ALL; DocNode existing; // Add values that existed before the change. First check for exact match by // global index, which will happen when explicit modifications are added, // and then by content identity. if (mapIndexToChild.TryGetValue(nodePep.Id.GlobalIndex, out existing) || mapIdToChild.TryGetValue(nodePep.Key, out existing)) { nodePepResult = (PeptideDocNode) existing; diffNode = diff; } if (nodePepResult != null) { // Materialize children of the peptide. nodePepResult = nodePepResult.ChangeSettings(settingsNew, diffNode); childrenNew.Add(nodePepResult); // Make sure a single peptide group does not exceed document limits. countPeptides++; countIons += nodePepResult.TransitionCount; if (countIons > SrmDocument.MAX_TRANSITION_COUNT) throw new InvalidDataException(String.Format( Resources.PeptideGroupDocNode_ChangeSettings_The_current_document_settings_would_cause_the_number_of_targeted_transitions_to_exceed__0_n0___The_document_settings_must_be_more_restrictive_or_add_fewer_proteins_, SrmDocument.MAX_TRANSITION_COUNT)); if (countPeptides > SrmDocument.MAX_PEPTIDE_COUNT) throw new InvalidDataException(String.Format( Resources.PeptideGroupDocNode_ChangeSettings_The_current_document_settings_would_cause_the_number_of_peptides_to_exceed__0_n0___The_document_settings_must_be_more_restrictive_or_add_fewer_proteins_, SrmDocument.MAX_PEPTIDE_COUNT)); } } if (PeptideGroup.Sequence != null) childrenNew = PeptideGroup.RankPeptides(childrenNew, settingsNew, true); return (PeptideGroupDocNode) ChangeChildrenChecked(childrenNew); } else { var nodeResult = this; if (diff.DiffPeptides && diff.SettingsOld != null) { // If variable modifications changed, remove all peptides with variable // modifications which are no longer possible. var modsNew = settingsNew.PeptideSettings.Modifications; var modsVarNew = modsNew.VariableModifications.ToArray(); var modsOld = diff.SettingsOld.PeptideSettings.Modifications; var modsVarOld = modsOld.VariableModifications.ToArray(); if (modsNew.MaxVariableMods < modsOld.MaxVariableMods || !ArrayUtil.EqualsDeep(modsVarNew, modsVarOld)) { IList<DocNode> childrenNew = new List<DocNode>(); foreach (PeptideDocNode nodePeptide in nodeResult.Children) { if (nodePeptide.AreVariableModsPossible(modsNew.MaxVariableMods, modsVarNew)) childrenNew.Add(nodePeptide); } nodeResult = (PeptideGroupDocNode)nodeResult.ChangeChildrenChecked(childrenNew); } } // Check for changes affecting children if (diff.DiffPeptideProps || diff.DiffExplicit || diff.DiffTransitionGroups || diff.DiffTransitionGroupProps || diff.DiffTransitions || diff.DiffTransitionProps || diff.DiffResults) { IList<DocNode> childrenNew = new List<DocNode>(); // Enumerate the nodes making necessary changes. foreach (PeptideDocNode nodePeptide in nodeResult.Children) childrenNew.Add(nodePeptide.ChangeSettings(settingsNew, diff)); childrenNew = RankChildren(settingsNew, childrenNew); nodeResult = (PeptideGroupDocNode)nodeResult.ChangeChildrenChecked(childrenNew); } return nodeResult; } }
public PeptideDocNode ChangeSettings(SrmSettings settingsNew, SrmSettingsDiff diff, bool recurse = true) { if (diff.Monitor != null) diff.Monitor.ProcessMolecule(this); // If the peptide has explicit modifications, and the modifications have // changed, see if any of the explicit modifications have changed var explicitMods = ExplicitMods; if (HasExplicitMods && !diff.IsUnexplainedExplicitModificationAllowed && diff.SettingsOld != null && !ReferenceEquals(settingsNew.PeptideSettings.Modifications, diff.SettingsOld.PeptideSettings.Modifications)) { explicitMods = ExplicitMods.ChangeGlobalMods(settingsNew); if (explicitMods == null || !ArrayUtil.ReferencesEqual(explicitMods.GetHeavyModifications().ToArray(), ExplicitMods.GetHeavyModifications().ToArray())) { diff = new SrmSettingsDiff(diff, SrmSettingsDiff.ALL); } else if (!ReferenceEquals(explicitMods.StaticModifications, ExplicitMods.StaticModifications)) { diff = new SrmSettingsDiff(diff, SrmSettingsDiff.PROPS); } } TransitionSettings transitionSettings = settingsNew.TransitionSettings; PeptideDocNode nodeResult = this; if (!ReferenceEquals(explicitMods, ExplicitMods)) nodeResult = nodeResult.ChangeExplicitMods(explicitMods); nodeResult = nodeResult.UpdateModifiedSequence(settingsNew); if (diff.DiffPeptideProps) { var rt = settingsNew.PeptideSettings.Prediction.RetentionTime; bool isStandard = Equals(nodeResult.GlobalStandardType, STANDARD_TYPE_IRT); if (rt != null) { bool isStandardNew = rt.IsStandardPeptide(nodeResult); if (isStandard ^ isStandardNew) nodeResult = nodeResult.ChangeStandardType(isStandardNew ? STANDARD_TYPE_IRT : null); } else if (isStandard) { nodeResult = nodeResult.ChangeStandardType(null); } } if (diff.DiffTransitionGroups && settingsNew.TransitionSettings.Filter.AutoSelect && AutoManageChildren) { IList<DocNode> childrenNew = new List<DocNode>(); PeptideRankId rankId = settingsNew.PeptideSettings.Libraries.RankId; bool useHighestRank = (rankId != null && settingsNew.PeptideSettings.Libraries.PeptideCount.HasValue); bool isPickedIntensityRank = useHighestRank && ReferenceEquals(rankId, LibrarySpec.PEP_RANK_PICKED_INTENSITY); Dictionary<Identity, DocNode> mapIdToChild = CreateIdContentToChildMap(); foreach (TransitionGroup tranGroup in GetTransitionGroups(settingsNew, explicitMods, true)) { TransitionGroupDocNode nodeGroup; SrmSettingsDiff diffNode = diff; DocNode existing; // Add values that existed before the change, unless using picked intensity ranking, // since this could bias the ranking, otherwise. if (!isPickedIntensityRank && mapIdToChild.TryGetValue(tranGroup, out existing)) nodeGroup = (TransitionGroupDocNode)existing; // Add new node else { TransitionDocNode[] transitions = !isPickedIntensityRank ? GetMatchingTransitions(tranGroup, settingsNew, explicitMods) : null; nodeGroup = new TransitionGroupDocNode(tranGroup, transitions); // If not recursing, then ChangeSettings will not be called on nodeGroup. So, make // sure its precursor m/z is set correctly. if (!recurse) nodeGroup = nodeGroup.ChangePrecursorMz(settingsNew, explicitMods); diffNode = SrmSettingsDiff.ALL; } if (nodeGroup != null) { TransitionGroupDocNode nodeChanged = recurse ? nodeGroup.ChangeSettings(settingsNew, nodeResult, explicitMods, diffNode) : nodeGroup; if (transitionSettings.IsMeasurablePrecursor(nodeChanged.PrecursorMz)) childrenNew.Add(nodeChanged); } } // If only using rank limited peptides, then choose only the single // highest ranked precursor charge. if (useHighestRank) { childrenNew = FilterHighestRank(childrenNew, rankId); // If using picked intensity, make sure original nodes are replaced if (isPickedIntensityRank) { for (int i = 0; i < childrenNew.Count; i++) { var nodeNew = (TransitionGroupDocNode) childrenNew[i]; DocNode existing; if (mapIdToChild.TryGetValue(nodeNew.TransitionGroup, out existing)) childrenNew[i] = existing; } } } nodeResult = (PeptideDocNode) nodeResult.ChangeChildrenChecked(childrenNew); } else { // Even with auto-select off, transition groups for which there is // no longer a precursor calculator must be removed. if (diff.DiffTransitionGroups && nodeResult.HasHeavyTransitionGroups) { IList<DocNode> childrenNew = new List<DocNode>(); foreach (TransitionGroupDocNode nodeGroup in nodeResult.Children) { if (settingsNew.HasPrecursorCalc(nodeGroup.TransitionGroup.LabelType, explicitMods)) childrenNew.Add(nodeGroup); } nodeResult = (PeptideDocNode)nodeResult.ChangeChildrenChecked(childrenNew); } // Update properties and children, if necessary if (diff.DiffTransitionGroupProps || diff.DiffTransitions || diff.DiffTransitionProps || diff.DiffResults) { IList<DocNode> childrenNew = new List<DocNode>(); // Enumerate the nodes making necessary changes. foreach (TransitionGroupDocNode nodeGroup in nodeResult.Children) { TransitionGroupDocNode nodeChanged = nodeGroup.ChangeSettings(settingsNew, nodeResult, explicitMods, diff); // Skip if the node can no longer be measured on the target instrument if (!transitionSettings.IsMeasurablePrecursor(nodeChanged.PrecursorMz)) continue; // Skip this node, if it is heavy and the update caused it to have the // same m/z value as the light value. if (!nodeChanged.TransitionGroup.LabelType.IsLight && !Peptide.IsCustomIon) // No mods on customs { double precursorMassLight = settingsNew.GetPrecursorMass( IsotopeLabelType.light, Peptide.Sequence, explicitMods); double precursorMzLight = SequenceMassCalc.GetMZ(precursorMassLight, nodeChanged.TransitionGroup.PrecursorCharge); if (nodeChanged.PrecursorMz == precursorMzLight) continue; } childrenNew.Add(nodeChanged); } nodeResult = (PeptideDocNode)nodeResult.ChangeChildrenChecked(childrenNew); } } if (diff.DiffResults || ChangedResults(nodeResult)) nodeResult = nodeResult.UpdateResults(settingsNew /*, diff*/); return nodeResult; }
public PeptideDocNode MergeUserInfo(PeptideDocNode nodePepMerge, SrmSettings settings, SrmSettingsDiff diff) { var result = Merge(nodePepMerge, (n, nMerge) => n.MergeUserInfo(nodePepMerge, nMerge, settings, diff)); var annotations = Annotations.Merge(nodePepMerge.Annotations); if (!ReferenceEquals(annotations, Annotations)) result = (PeptideDocNode) result.ChangeAnnotations(annotations); return result.UpdateResults(settings); }
public override IEnumerable<DocNode> GetChoices(bool useFilter) { var nodePep = PepNode; if (nodePep == null) { throw new InvalidOperationException( Resources.TransitionGroupTreeNode_GetChoices_Invalid_attempt_to_get_choices_for_a_node_that_has_not_been_added_to_the_tree_yet); } var listChildrenNew = GetChoices(DocNode, DocSettings, nodePep.ExplicitMods, useFilter); // Existing transitions must be part of the first settings change to ensure proper // handling of user set peak boundaries. MergeChosen(listChildrenNew, useFilter, node => ((TransitionDocNode)node).Key(DocNode)); var nodeGroup = (TransitionGroupDocNode)DocNode.ChangeChildrenChecked(listChildrenNew); var diff = new SrmSettingsDiff(DocSettings, true); // Update results on the group to correctly handle user set peak boundaries nodeGroup = nodeGroup.UpdateResults(DocSettings, diff, nodePep, DocNode); // Make sure any properties that depend on peptide relationships, // like ratios get updated. nodePep = (PeptideDocNode)nodePep.ReplaceChild(nodeGroup); diff = new SrmSettingsDiff(diff, SrmSettingsDiff.PROPS); nodePep = nodePep.ChangeSettings(DocSettings, diff); var id = nodeGroup.Id; int iGroup = nodePep.Children.IndexOf(n => ReferenceEquals(n.Id, id)); if (iGroup != -1) nodeGroup = (TransitionGroupDocNode)nodePep.Children[iGroup]; listChildrenNew = new List<DocNode>(nodeGroup.Children); // Merge with existing transitions again to avoid changes based on the settings // updates. MergeChosen(listChildrenNew, useFilter, node => ((TransitionDocNode)node).Key(nodeGroup)); return listChildrenNew; }