Merge pull request #175 from rmillikin/master

merge

Author: stefanks

InternalLogic/AnalysisEngine.cs

@@ -486,8 +486,8 @@ public void ScoreProteinGroups(List<ProteinGroup> proteinGroups, List<NewPsmWith
                 proteinGroup.UniquePeptideList = newUniquePeptideList;
 
                 // score the group (scoring algorithm defined in the ProteinGroup class)
-                proteinGroup.scoreThisProteinGroup();
-
+                proteinGroup.ScoreThisProteinGroup();
+                
                 // remove empty protein groups (peptides were too poor quality and group doesn't exist anymore)
                 if (proteinGroup.proteinGroupScore == 0)
                     proteinGroupsToRemove.Add(proteinGroup);
@@ -504,17 +504,28 @@ public void ScoreProteinGroups(List<ProteinGroup> proteinGroups, List<NewPsmWith
                 if (kvp.Value.Count > 1)
                     allRazorPeptides.Add(kvp.Key);
             }
-
-            // build razor peptide list for each protein group
+            
             foreach (var proteinGroup in proteinGroups)
             {
                 foreach (var peptide in proteinGroup.PeptideList)
                 {
+                    // build razor peptide list for each protein group
                     if (allRazorPeptides.Contains(peptide))
                     {
                         proteinGroup.RazorPeptideList.Add(peptide);
                     }
+
+                    // build PeptideWithSetMod list to calc sequence coverage
+                    HashSet<PeptideWithSetModifications> peptidesWithSetMods = null;
+                    compactPeptideToProteinPeptideMatching.TryGetValue(peptide, out peptidesWithSetMods);
+                    foreach(var pep in peptidesWithSetMods)
+                    {
+                        proteinGroup.PeptideWithSetModsList.Add(pep);
+                    }
                 }
+
+                // calculate sequence coverage for each protein in the group
+                proteinGroup.CalculateSequenceCoverage();
             }
         }
 

InternalLogic/ProteinGroup.cs

@@ -11,7 +11,7 @@ public class ProteinGroup
         #region Public Fields
 
         public readonly bool isDecoy;
-        public double proteinGroupScore;
+        public double proteinGroupScore { get; private set; }
 
         #endregion Public Fields
 
@@ -25,6 +25,7 @@ internal ProteinGroup(HashSet<Protein> proteins, HashSet<CompactPeptide> peptide
             BestPsmList = null;
             TotalPsmList = new List<NewPsmWithFdr>();
             RazorPeptideList = new HashSet<CompactPeptide>();
+            PeptideWithSetModsList = new HashSet<PeptideWithSetModifications>();
             proteinGroupScore = 0;
             QValue = 0;
             isDecoy = false;
@@ -53,6 +54,7 @@ public static string TabSeparatedHeader
                 sb.Append("Razor peptides" + '\t');
                 sb.Append("Number of peptides" + '\t');
                 sb.Append("Number of unique peptides" + '\t');
+                sb.Append("Sequence coverage" + '\t');
                 sb.Append("Number of PSMs" + '\t');
                 sb.Append("Summed MetaMorpheus Score" + '\t');
                 sb.Append("Decoy?" + '\t');
@@ -68,6 +70,8 @@ public static string TabSeparatedHeader
         public List<NewPsmWithFdr> TotalPsmList { get; set; }
         public HashSet<CompactPeptide> PeptideList { get; set; }
         public HashSet<CompactPeptide> UniquePeptideList { get; set; }
+        public HashSet<PeptideWithSetModifications> PeptideWithSetModsList { get; set; }
+        public List<double> sequenceCoverage { get; private set; }
         public HashSet<CompactPeptide> RazorPeptideList { get; set; }
         public double QValue { get; set; }
         public int cumulativeTarget { get; set; }
@@ -128,7 +132,17 @@ public override string ToString()
             sb.Append("" + UniquePeptideList.Count());
             sb.Append("\t");
 
-            // number of PSMs for final base sequences
+            // sequence coverage
+            foreach (double coverage in sequenceCoverage)
+            {
+                double coverage1 = coverage * 100;
+                string str = string.Format("{0:0}", coverage1);
+                
+                sb.Append("" + str + "% ;; ");
+            }
+            sb.Append("\t");
+
+            // number of PSMs for listed peptides
             sb.Append("" + TotalPsmList.Count());
             sb.Append("\t");
 
@@ -155,7 +169,7 @@ public override string ToString()
             return sb.ToString();
         }
 
-        public void scoreThisProteinGroup()
+        public void ScoreThisProteinGroup()
         {
             // score the protein group
             foreach (var psm in BestPsmList)
@@ -164,6 +178,27 @@ public void scoreThisProteinGroup()
             }
         }
 
+        public void CalculateSequenceCoverage()
+        {
+            sequenceCoverage = new List<double>();
+
+            foreach (var protein in Proteins)
+            {
+                HashSet<int> coveredResidues = new HashSet<int>();
+
+                foreach(var peptide in PeptideWithSetModsList)
+                {
+                    for(int i = peptide.OneBasedStartResidueInProtein; i <= peptide.OneBasedEndResidueInProtein; i++)
+                    {
+                        coveredResidues.Add(i);
+                    }
+                }
+
+                double sequenceCoverageHere = (double)coveredResidues.Count / protein.Length;
+                sequenceCoverage.Add(sequenceCoverageHere);
+            }
+        }
+
         #endregion Public Methods
 
     }

Test/RobTest.cs

@@ -29,32 +29,35 @@ public static void TestParsimony()
             var totalVirtualPeptideList = new HashSet<PeptideWithSetModifications>();
 
             var p1 = new Protein(sequence1, "1", temp1, temp3, temp3, null, "Test1", "TestFullName1", 0, false, false);
-            var p2 = new Protein(sequence2, "2", temp1, temp3, temp3, null, "Test2", "TestFullName2", 0, false, false);
+            var p2 = new Protein(sequence2, "2", temp1, temp3, temp3, null, "DECOY_Test2", "DECOY_TestFullName2", 0, true, false);
             var p3 = new Protein(sequence3, "3", temp1, temp3, temp3, null, "Test3", "TestFullName3", 0, false, false);
 
             IEnumerable<PeptideWithPossibleModifications> digestedList1 = p1.Digest(protease, 2, InitiatorMethionineBehavior.Variable);
             IEnumerable<PeptideWithPossibleModifications> digestedList2 = p2.Digest(protease, 2, InitiatorMethionineBehavior.Variable);
             IEnumerable<PeptideWithPossibleModifications> digestedList3 = p3.Digest(protease, 2, InitiatorMethionineBehavior.Variable);
+            IEnumerable<PeptideWithSetModifications> peptides1 = null;
+            IEnumerable<PeptideWithSetModifications> peptides2 = null;
+            IEnumerable<PeptideWithSetModifications> peptides3 = null;
 
             foreach (var protein in digestedList1)
             {
-                IEnumerable<PeptideWithSetModifications> peptides1 = protein.GetPeptideWithSetModifications(temp2, 4098, 3);
+                peptides1 = protein.GetPeptideWithSetModifications(temp2, 4098, 3);
 
                 foreach (var peptide in peptides1)
                     totalVirtualPeptideList.Add(peptide);
             }
 
             foreach (var protein in digestedList2)
             {
-                IEnumerable<PeptideWithSetModifications> peptides2 = protein.GetPeptideWithSetModifications(temp2, 4098, 3);
+                peptides2 = protein.GetPeptideWithSetModifications(temp2, 4098, 3);
 
                 foreach (var peptide in peptides2)
                     totalVirtualPeptideList.Add(peptide);
             }
 
             foreach (var protein in digestedList3)
             {
-                IEnumerable<PeptideWithSetModifications> peptides3 = protein.GetPeptideWithSetModifications(temp2, 4098, 3);
+                peptides3 = protein.GetPeptideWithSetModifications(temp2, 4098, 3);
 
                 foreach (var peptide in peptides3)
                     totalVirtualPeptideList.Add(peptide);
@@ -95,11 +98,18 @@ public static void TestParsimony()
                     dictionary.Add(peptides[i], virtualPeptideSets[i]);
                 }
             }
-            List<ProteinGroup> pg = new List<ProteinGroup>();
+            List<ProteinGroup> proteinGroups = new List<ProteinGroup>();
             AnalysisEngine ae = new AnalysisEngine(null, dictionary, null, null, null, null, null, null, null, null, null, null, null, true, 0, 0, false, new List<ProductType> { ProductType.B, ProductType.Y });
 
+            Dictionary<CompactPeptide, HashSet<PeptideWithSetModifications>> initialDictionary = new Dictionary<CompactPeptide, HashSet<PeptideWithSetModifications>>();
+            foreach(var kvp in dictionary)
+            {
+                initialDictionary.Add(kvp.Key, kvp.Value);
+            }
+
+
             // apply parsimony to initial dictionary
-            ae.ApplyProteinParsimony(out pg);
+            ae.ApplyProteinParsimony(out proteinGroups);
 
             var parsimonyProteinList = new List<Protein>();
             string[] parsimonyBaseSequences = new string[3];
@@ -121,50 +131,90 @@ public static void TestParsimony()
                 }
             }
 
+            
+
+            List<NewPsmWithFdr> psms = new List<NewPsmWithFdr>();
+
+            foreach(var kvp in dictionary)
+            {
+                foreach(var peptide in kvp.Value)
+                {
+                    HashSet<PeptideWithSetModifications> hashSet = new HashSet<PeptideWithSetModifications>();
+                    hashSet.Add(peptide);
+
+                    switch (peptide.BaseSequence)
+                    {
+                        case "AK": psms.Add(new NewPsmWithFdr(new PSMwithProteinHashSet(new ClassicSpectrumMatch(peptide, null, 0, 0, 0, 0, 0, 0, 0, 0, 1), hashSet, null, null, null), 1, 0, 0.29)); break;
+                        case "CK": psms.Add(new NewPsmWithFdr(new PSMwithProteinHashSet(new ClassicSpectrumMatch(peptide, null, 0, 0, 0, 0, 0, 0, 0, 0, 9), hashSet, null, null, null), 1, 0, 0.0)); break;
+                        case "BK": psms.Add(new NewPsmWithFdr(new PSMwithProteinHashSet(new ClassicSpectrumMatch(peptide, null, 0, 0, 0, 0, 0, 0, 0, 0, 8), hashSet, null, null, null), 1, 0, 0.0)); break;
+                        case "AKCK": psms.Add(new NewPsmWithFdr(new PSMwithProteinHashSet(new ClassicSpectrumMatch(peptide, null, 0, 0, 0, 0, 0, 0, 0, 0, 7), hashSet, null, null, null), 1, 0, 0.0)); break;
+                        case "CKBK": psms.Add(new NewPsmWithFdr(new PSMwithProteinHashSet(new ClassicSpectrumMatch(peptide, null, 0, 0, 0, 0, 0, 0, 0, 0, 6), hashSet, null, null, null), 1, 0, 0.0)); break;
+                        case "AKCKBK": psms.Add(new NewPsmWithFdr(new PSMwithProteinHashSet(new ClassicSpectrumMatch(peptide, null, 0, 0, 0, 0, 0, 0, 0, 0, 5), hashSet, null, null, null), 1, 0, 0.0)); break;
+                        case "DK": psms.Add(new NewPsmWithFdr(new PSMwithProteinHashSet(new ClassicSpectrumMatch(peptide, null, 0, 0, 0, 0, 0, 0, 0, 0, 4), hashSet, null, null, null), 1, 0, 0.2)); break;
+                        case "DKCK": psms.Add(new NewPsmWithFdr(new PSMwithProteinHashSet(new ClassicSpectrumMatch(peptide, null, 0, 0, 0, 0, 0, 0, 0, 0, 3), hashSet, null, null, null), 1, 0, 0.4)); break;
+                        case "AAAAK": psms.Add(new NewPsmWithFdr(new PSMwithProteinHashSet(new ClassicSpectrumMatch(peptide, null, 0, 0, 0, 0, 0, 0, 0, 0, 2), hashSet, null, null, null), 1, 0, 0.33)); break;
+                    }
+                }
+            }
+
+            ae.ScoreProteinGroups(proteinGroups, psms);
+            ae.DoProteinFdr(proteinGroups);
+
+
             /*
             // prints initial dictionary
             List<Protein> proteinList = new List<Protein>();
 
-            Console.WriteLine("----Initial Dictionary----");
-            Console.WriteLine("PEPTIDE\t\t\tPROTEIN\t\t\tPeptideWithSetModifications");
+            System.Console.WriteLine("----Initial Dictionary----");
+            System.Console.WriteLine("PEPTIDE\t\t\tPROTEIN\t\t\tPeptideWithSetModifications");
             foreach (var kvp in initialDictionary)
             {
                 proteinList = new List<Protein>();
-                Console.Write(string.Join("", kvp.Key.BaseSequence.Select(b => char.ConvertFromUtf32(b))) + "  \t\t\t  ");
+                System.Console.Write(string.Join("", kvp.Key.BaseSequence.Select(b => char.ConvertFromUtf32(b))) + "  \t\t\t  ");
                 foreach (var peptide in kvp.Value)
                 {
-                    if (!proteinList.Contains(peptide.protein))
+                    if (!proteinList.Contains(peptide.Protein))
                     {
-                        Console.Write(peptide.protein.BaseSequence + " ;; ");
-                        proteinList.Add(peptide.protein);
+                        System.Console.Write(peptide.Protein.BaseSequence + " ;; ");
+                        proteinList.Add(peptide.Protein);
                     }
                 }
-                Console.WriteLine();
+                System.Console.WriteLine();
             }
 
             // prints parsimonious dictionary
-            Console.WriteLine("----Parsimonious Dictionary----");
-            Console.WriteLine("PEPTIDE\t\t\tPROTEIN\t\t\tPeptideWithSetModifications");
-            foreach (var kvp in parsimonyTest)
+            System.Console.WriteLine("----Parsimonious Dictionary----");
+            System.Console.WriteLine("PEPTIDE\t\t\tPROTEIN\t\t\tPeptideWithSetModifications");
+            foreach (var kvp in dictionary)
             {
                 proteinList = new List<Protein>();
-                Console.Write(string.Join("", kvp.Key.BaseSequence.Select(b => char.ConvertFromUtf32(b))) + "  \t\t\t  ");
+                System.Console.Write(string.Join("", kvp.Key.BaseSequence.Select(b => char.ConvertFromUtf32(b))) + "  \t\t\t  ");
                 foreach (var peptide in kvp.Value)
                 {
-                    if (!proteinList.Contains(peptide.protein))
+                    if (!proteinList.Contains(peptide.Protein))
                     {
-                        Console.Write(peptide.protein.BaseSequence + " ;; ");
-                        proteinList.Add(peptide.protein);
+                        System.Console.Write(peptide.Protein.BaseSequence + " ;; ");
+                        proteinList.Add(peptide.Protein);
                     }
                 }
-                Console.WriteLine();
+                System.Console.WriteLine();
+            }
+
+
+            // prints protein groups after scoring/fdr
+            System.Console.WriteLine(ProteinGroup.TabSeparatedHeader);
+            foreach (var proteinGroup in proteinGroups)
+            {
+                System.Console.WriteLine(proteinGroup);
             }
             */
 
             Assert.That(parsimonyProteinList.Count == 3);
             Assert.That(parsimonyBaseSequences.Contains(sequence1));
             Assert.That(parsimonyBaseSequences.Contains(sequence2));
             Assert.That(parsimonyBaseSequences.Contains(sequence3));
+            Assert.That(proteinGroups.Count == 2);
+            Assert.That(proteinGroups.First().proteinGroupScore > 10);
         }
 
         #endregion Public Methods