public void SettingsChangeNotDoc() { SrmDocument docFasta = CreateMixedDoc(); SrmSettings settings = docFasta.Settings; // Change declustering potential, collision energy, and retention time var regressions = new DeclusterPotentialList(); regressions.AddDefaults(); var dpRegress = regressions["SCIEX"]; var collisions = new CollisionEnergyList(); collisions.AddDefaults(); var ceRegress = collisions["SCIEX"]; var calc = Settings.Default.RTScoreCalculatorList.GetDefaults().First(); var rtRegress = new RetentionTimeRegression("Test", calc, 3.5, 10.4, 12.8, new MeasuredRetentionTime[0]); SrmSettings settings2 = settings.ChangePeptidePrediction(p => p.ChangeRetentionTime(rtRegress)). ChangeTransitionPrediction(p => p.ChangeCollisionEnergy(ceRegress).ChangeDeclusteringPotential(dpRegress)); SrmDocument docFasta2 = docFasta.ChangeSettings(settings2); AssertEx.IsDocumentState(docFasta2, docFasta.RevisionIndex + 1, 3, 111, 352); Assert.AreSame(docFasta.Children, docFasta2.Children); Assert.AreNotEqual(docFasta.Settings, docFasta2.Settings); // Change auto-select toggles SrmSettings settings3 = settings.ChangePeptideFilter(f => f.ChangeAutoSelect(false)). ChangeTransitionFilter(f => f.ChangeAutoSelect(false)); SrmDocument docFasta3 = docFasta.ChangeSettings(settings3); AssertEx.IsDocumentState(docFasta3, docFasta.RevisionIndex + 1, 3, 111, 352); Assert.AreSame(docFasta.Children, docFasta3.Children); Assert.AreNotEqual(docFasta.Settings, docFasta3.Settings); }
public void SettingsChangePeptides() { SrmDocument docFasta = CreateMixedDoc(); const int posList = 0; // Peptide list is first peptide group. SrmSettings settings = docFasta.Settings; // Change enzymes, and verify expected peptide changes var enzymes = new EnzymeList(); enzymes.AddDefaults(); SrmDocument docCnbr = docFasta.ChangeSettings(settings.ChangePeptideSettings( p => p.ChangeEnzyme(enzymes["CNBr [M | P]"]))); foreach (PeptideDocNode nodePeptide in docCnbr.Peptides) { if (nodePeptide.Peptide.FastaSequence == null) { continue; } Peptide peptide = nodePeptide.Peptide; char prev = peptide.PrevAA; if (prev != 'M') { Assert.Fail("Unexpected preceding cleavage at {0}", prev); } string seq = peptide.Sequence; char last = seq[seq.Length - 1]; if (last != 'M' && peptide.NextAA != '-') { Assert.Fail("Unexpected cleavage at {0}", last); } } Assert.IsTrue(docCnbr.PeptideCount < docFasta.PeptideCount); // Peptide list should not have changed. Assert.AreSame(docFasta.Children[posList], docCnbr.Children[posList]); // Change back to original enzyme, and make sure peptides are restored SrmDocument docFasta2 = docCnbr.ChangeSettings(settings); Assert.AreEqual(docFasta.RevisionIndex + 2, docFasta2.RevisionIndex); Assert.AreEqual(docFasta.PeptideCount, docFasta2.PeptideCount); Assert.AreEqual(docFasta.PeptideTransitionCount, docFasta2.PeptideTransitionCount); // Allow missed cleavages, and verify changes docFasta2 = docFasta.ChangeSettings(settings.ChangePeptideSettings( p => p.ChangeDigestSettings(new DigestSettings(1, false)))); Assert.IsTrue(docFasta.PeptideCount < docFasta2.PeptideCount); // TODO: Make minimum transition count work immediately // Assert.IsTrue((docFasta2.PeptideCount - docFasta.PeptideCount) * 3 < // docFasta2.TransitionCount - docFasta.TransitionCount); int missedCleavageCount = 0; var dictOrig = docFasta.Peptides.ToDictionary(node => node.Peptide); foreach (PeptideDocNode nodePeptide in docFasta2.Peptides) { // Make sure all zero-cleavage peptides are the same as the old document int missed = nodePeptide.Peptide.MissedCleavages; if (missed == 0) { Assert.AreEqual(nodePeptide, dictOrig[nodePeptide.Peptide]); } // Count the number of new missed cleavages missedCleavageCount += nodePeptide.Peptide.MissedCleavages; } Assert.AreEqual(docFasta2.PeptideCount - docFasta.PeptideCount, missedCleavageCount); // Peptide list should not have changed. Assert.AreSame(docFasta.Children[posList], docFasta2.Children[posList]); // Increase minimum peptide length const int minNew = 12; docFasta2 = docFasta.ChangeSettings(settings.ChangePeptideFilter(f => f.ChangeMinPeptideLength(minNew))); CheckPeptides(docFasta, docFasta2, node => node.Peptide.Length >= minNew); Assert.AreSame(docFasta.Children[posList], docFasta2.Children[posList]); // Decrease maximum peptide length const int maxNew = 18; docFasta2 = docFasta.ChangeSettings(settings.ChangePeptideFilter(f => f.ChangeMaxPeptideLength(maxNew))); CheckPeptides(docFasta, docFasta2, node => node.Peptide.Length <= maxNew); Assert.AreSame(docFasta.Children[posList], docFasta2.Children[posList]); // Increase n-term AA exclustion const int ntermStart = 50; docFasta2 = docFasta.ChangeSettings(settings.ChangePeptideFilter( f => f.ChangeExcludeNTermAAs(ntermStart))); CheckPeptides(docFasta, docFasta2, node => node.Peptide.Begin.HasValue && node.Peptide.Begin.Value >= ntermStart); Assert.AreSame(docFasta.Children[posList], docFasta2.Children[posList]); // Use ragged end exclusion docFasta2 = docFasta.ChangeSettings(settings.ChangePeptideSettings( p => p.ChangeDigestSettings(new DigestSettings(0, true)))); CheckPeptides(docFasta, docFasta2, IsNotRagged); Assert.AreSame(docFasta.Children[posList], docFasta2.Children[posList]); // Check custom exclusions var exclusions = new PeptideExcludeList(); exclusions.AddDefaults(); // Exclude Cys docFasta2 = docFasta.ChangeSettings(settings.ChangePeptideFilter( f => f.ChangeExclusions(new[] { exclusions["Cys"] }))); CheckPeptides(docFasta, docFasta2, node => node.Peptide.Sequence.IndexOf('C') == -1); Assert.AreSame(docFasta.Children[posList], docFasta2.Children[posList]); // Exclude Met docFasta2 = docFasta.ChangeSettings(settings.ChangePeptideFilter( f => f.ChangeExclusions(new[] { exclusions["Met"] }))); CheckPeptides(docFasta, docFasta2, node => node.Peptide.Sequence.IndexOf('M') == -1); // Exclude Hys docFasta2 = docFasta.ChangeSettings(settings.ChangePeptideFilter( f => f.ChangeExclusions(new[] { exclusions["His"] }))); CheckPeptides(docFasta, docFasta2, node => node.Peptide.Sequence.IndexOf('H') == -1); // Exclude NXS/NXT Regex regexNx = new Regex("N.[ST]"); docFasta2 = docFasta.ChangeSettings(settings.ChangePeptideFilter( f => f.ChangeExclusions(new[] { exclusions["NXT/NXS"] }))); CheckPeptides(docFasta, docFasta2, node => !regexNx.Match(node.Peptide.Sequence).Success); // Exclude RP/KP docFasta2 = docFasta.ChangeSettings(settings.ChangePeptideFilter( f => f.ChangeExclusions(new[] { exclusions["RP/KP"] }))); CheckPeptides(docFasta, docFasta2, node => node.Peptide.Sequence.IndexOf("RP", StringComparison.Ordinal) == -1 && node.Peptide.Sequence.IndexOf("KP", StringComparison.Ordinal) == -1); // Custom exclude ^Q*K$ var excludeCustom = new PeptideExcludeRegex("Custom", "^Q.*K$"); docFasta2 = docFasta.ChangeSettings(settings.ChangePeptideFilter( f => f.ChangeExclusions(new[] { excludeCustom }))); CheckPeptides(docFasta, docFasta2, node => (!node.Peptide.Sequence.StartsWith("Q") || !node.Peptide.Sequence.EndsWith("K"))); // Auto-picking off should keep any changes from occurring docFasta2 = docFasta.ChangeSettings(settings.ChangePeptideFilter( f => f.ChangeAutoSelect(false).ChangeExclusions(new[] { exclusions["Cys"], exclusions["Met"], excludeCustom }))); Assert.AreSame(docFasta.Children, docFasta2.Children); // Removing restriction with auto-picking off should change anything settings = docFasta2.Settings; SrmDocument docFasta3 = docFasta2.ChangeSettings(settings.ChangePeptideFilter( f => f.ChangeExclusions(new PeptideExcludeRegex[0]))); Assert.AreSame(docFasta2.Children, docFasta3.Children); }
public PeptideGroupDocNode ChangeSettings(SrmSettings settingsNew, SrmSettingsDiff diff, DocumentSettingsContext context = null) { 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(); IEnumerable <PeptideDocNode> peptideDocNodes; if (settingsNew.PeptideSettings.Filter.PeptideUniqueness == PeptideFilter.PeptideUniquenessConstraint.none || settingsNew.PeptideSettings.NeedsBackgroundProteomeUniquenessCheckProcessing) { peptideDocNodes = GetPeptideNodes(settingsNew, true).ToList(); } else { // Checking peptide uniqueness against the background proteome can be expensive. // Do all the regular processing, then filter those results at the end when we // can do it in aggregate for best speed. IEnumerable <PeptideDocNode> peptideDocNodesUnique; var peptideDocNodesPrecalculatedForUniquenessCheck = context == null ? null : context.PeptideDocNodesPrecalculatedForUniquenessCheck; var uniquenessDict = context == null ? null : context.UniquenessDict; if (peptideDocNodesPrecalculatedForUniquenessCheck != null) { // Already processed, and a global list of peptides provided Assume.IsNotNull(uniquenessDict); peptideDocNodesUnique = peptideDocNodesPrecalculatedForUniquenessCheck; } else { // We'll have to do the processing for this node, and work with // just the peptides on this node. With luck the background proteome // will already have those cached for uniqueness checks. var settingsNoUniquenessFilter = settingsNew.ChangePeptideFilter(f => f.ChangePeptideUniqueness(PeptideFilter.PeptideUniquenessConstraint.none)); var nodes = GetPeptideNodes(settingsNoUniquenessFilter, true).ToList(); var sequences = new List <string>(from p in nodes select p.Peptide.Sequence); peptideDocNodesUnique = nodes; // Avoid ReSharper multiple enumeration warning uniquenessDict = settingsNew.PeptideSettings.Filter.CheckPeptideUniqueness(settingsNew, sequences, diff.Monitor); } // ReSharper disable once PossibleNullReferenceException peptideDocNodes = peptideDocNodesUnique.Where(p => { // It's possible during document load for uniqueness dict to get out of synch, so be // cautious with lookup and just return false of not found. Final document change will clean that up. bool isUnique; return(uniquenessDict.TryGetValue(p.Peptide.Sequence, out isUnique) && isUnique); }); } foreach (var nodePep in peptideDocNodes) { 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); } }