/// <summary> /// Gets a list of the peptide matches from the path provided. /// </summary> /// <param name="path"></param> /// <returns></returns> private List <PeptideMatch> GetPeptideMatches(string path) { var lines = File.ReadAllLines(path).ToList(); var matches = new List <PeptideMatch>(); foreach (var line in lines) { var data = line.Split(','); if (data.Length < 6) { continue; } try { var match = new PeptideMatch(); match.Peptide = data[5]; match.ScanX = Convert.ToInt32(data[1]); match.ScanY = Convert.ToInt32(data[3]); matches.Add(match); } catch { } } return(matches); }
/// <summary> /// Adds all peptides which can be matched to a background proteome to the /// proteins in the background proteins, and returns a new document with those /// proteins and peptides added. /// </summary> /// <param name="document">The starting document</param> /// <param name="dictCopy">A dictionary of peptides to peptide matches. All added /// peptides are removed</param> /// <param name="broker">For reporting long wait status</param> /// <param name="toPath">Path to the location in the document to add new items</param> /// <param name="selectedPath">Path to item in the document that should be selected /// after this operation is complete</param> /// <returns>A new document with matching peptides and their proteins addded</returns> private SrmDocument AddProteomePeptides(SrmDocument document, Dictionary <PeptideSequenceModKey, PeptideMatch> dictCopy, ILongWaitBroker broker, IdentityPath toPath, out IdentityPath selectedPath) { // Build a list of new PeptideGroupDocNodes to add to the document. var dictPeptideGroupsNew = new Dictionary <string, PeptideGroupDocNode>(); // Get starting progress values int startPercent = (broker != null ? broker.ProgressValue : 0); int processedPercent = 0; int processedCount = 0; int totalMatches = dictCopy.Count; // Just to make sure this is set selectedPath = toPath; foreach (PeptideMatch pepMatch in dictCopy.Values) { // Show progress, if in a long wait if (broker != null) { if (broker.IsCanceled) { selectedPath = toPath; return(document); } // All peptides with protein get processed in this loop. Peptides // without proteins get added later. if (pepMatch.Proteins != null) { processedCount++; } int processPercentNow = processedCount * (100 - startPercent) / totalMatches; if (processedPercent != processPercentNow) { processedPercent = processPercentNow; broker.ProgressValue = startPercent + processedPercent; } } // Peptide should be added to the document, // unless the NoDuplicates radio was selected and the peptide has more than 1 protein associated with it. if (pepMatch.Proteins == null || (FilterMultipleProteinMatches == BackgroundProteome.DuplicateProteinsFilter.NoDuplicates && pepMatch.Proteins.Count > 1)) { continue; } foreach (ProteinInfo protein in pepMatch.Proteins) { // Look for the protein in the document. string name = protein.ProteinMetadata.Name; var peptideGroupDocNode = FindPeptideGroupDocNode(document, name); bool foundInDoc = peptideGroupDocNode != null; bool foundInList = false; if (!foundInDoc) { // If the protein is not already in the document, // check to see if we have already created a PeptideGroupDocNode for it. if (name != null && dictPeptideGroupsNew.TryGetValue(name, out peptideGroupDocNode)) { foundInList = true; } // If not, create a new PeptideGroupDocNode. else { List <ProteinMetadata> alternativeProteins = new List <ProteinMetadata>(protein.Alternatives); peptideGroupDocNode = new PeptideGroupDocNode( new FastaSequence(name, protein.ProteinMetadata.Description, alternativeProteins, protein.Sequence), null, null, new PeptideDocNode[0]); } } // Create a new peptide that matches this protein. var fastaSequence = peptideGroupDocNode.PeptideGroup as FastaSequence; var peptideSequence = pepMatch.NodePep.Peptide.Target.Sequence; // ReSharper disable PossibleNullReferenceException var begin = fastaSequence.Sequence.IndexOf(peptideSequence, StringComparison.Ordinal); // ReSharper restore PossibleNullReferenceException // Create a new PeptideDocNode using this peptide. var newPeptide = new Peptide(fastaSequence, peptideSequence, begin, begin + peptideSequence.Length, Settings.PeptideSettings.Enzyme.CountCleavagePoints(peptideSequence)); // Make sure we keep the same children. PeptideMatch match = pepMatch; var newNodePep = ((PeptideDocNode) new PeptideDocNode(newPeptide, pepMatch.NodePep.ExplicitMods, pepMatch.NodePep.ExplicitRetentionTime) .ChangeChildren(pepMatch.NodePep.Children.ToList().ConvertAll(nodeGroup => { // Create copies of the children in order to prevent transition groups with the same // global indices. var nodeTranGroup = (TransitionGroupDocNode)nodeGroup; if (match.Proteins != null && match.Proteins.Count > 1) { nodeTranGroup = (TransitionGroupDocNode)nodeTranGroup.CopyId(); nodeTranGroup = (TransitionGroupDocNode)nodeTranGroup.ChangeChildren( nodeTranGroup.Children.ToList().ConvertAll(nodeTran => nodeTran.CopyId())); } return((DocNode)nodeTranGroup); })).ChangeAutoManageChildren(false)).ChangeSettings(document.Settings, SrmSettingsDiff.ALL); // If this PeptideDocNode is already a child of the PeptideGroupDocNode, // ignore it. if (peptideGroupDocNode.Children.Contains(nodePep => Equals(((PeptideDocNode)nodePep).Key, newNodePep.Key))) { Console.WriteLine(Resources.ViewLibraryPepMatching_AddProteomePeptides_Skipping__0__already_present, newNodePep.Peptide.Target); continue; } // Otherwise, add it to the list of children for the PeptideGroupNode. var newChildren = peptideGroupDocNode.Children.Cast <PeptideDocNode>().ToList(); newChildren.Add(newNodePep); newChildren.Sort(FastaSequence.ComparePeptides); // Store modified proteins by global index in a HashSet for second pass. var newPeptideGroupDocNode = peptideGroupDocNode.ChangeChildren(newChildren.Cast <DocNode>().ToArray()) .ChangeAutoManageChildren(false); // If the protein was already in the document, replace with the new PeptideGroupDocNode. if (foundInDoc) { document = (SrmDocument)document.ReplaceChild(newPeptideGroupDocNode); } // Otherwise, update the list of new PeptideGroupDocNodes to add. else { if (foundInList) { dictPeptideGroupsNew.Remove(peptideGroupDocNode.Name); } dictPeptideGroupsNew.Add(peptideGroupDocNode.Name, (PeptideGroupDocNode)newPeptideGroupDocNode); } // If we are only adding a single node, select it. if (PeptideMatches.Count == 1) { selectedPath = new IdentityPath(new[] { peptideGroupDocNode.Id, newNodePep.Peptide }); } // If the user only wants to add the first protein found, // we break the foreach loop after peptide has been added to its first protein.) if (FilterMultipleProteinMatches == BackgroundProteome.DuplicateProteinsFilter.FirstOccurence) { break; } } } if (dictPeptideGroupsNew.Count == 0) { return(document); } // Sort the peptides. var nodePepGroupsSortedChildren = new List <PeptideGroupDocNode>(); foreach (PeptideGroupDocNode nodePepGroup in dictPeptideGroupsNew.Values) { var newChildren = nodePepGroup.Children.ToList(); // Have to cast all children to PeptideDocNodes in order to sort. var newChildrenNodePeps = newChildren.Cast <PeptideDocNode>().ToList(); newChildrenNodePeps.Sort(FastaSequence.ComparePeptides); nodePepGroupsSortedChildren.Add((PeptideGroupDocNode) nodePepGroup.ChangeChildren(newChildrenNodePeps.Cast <DocNode>().ToArray())); } // Sort the proteins. nodePepGroupsSortedChildren.Sort((node1, node2) => Comparer <string> .Default.Compare(node1.Name, node2.Name)); IdentityPath selPathTemp = selectedPath, nextAdd; document = document.AddPeptideGroups(nodePepGroupsSortedChildren, false, toPath, out selectedPath, out nextAdd); selectedPath = PeptideMatches.Count == 1 ? selPathTemp : selectedPath; return(document); }