PTM Stoichiometry

mzLib/Chemistry/ClassExtensions.cs

@@ -48,6 +48,7 @@ public static double ToMass(this double massToChargeRatio, int charge)
             return Math.Abs(charge) * massToChargeRatio - charge * Constants.ProtonMass;
         }
 
+        public static double? RoundedDouble(this double myNumber, int places = 9) => RoundedDouble(myNumber as double?, places);
         public static double? RoundedDouble(this double? myNumber, int places = 9)
         {
             if (myNumber != null)

mzLib/FlashLFQ/FlashLFQResults.cs

@@ -1,5 +1,7 @@
 using Easy.Common.Extensions;
 using MathNet.Numerics.Statistics;
+using MzLibUtil;
+using Proteomics;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -14,6 +16,7 @@
         public readonly Dictionary<string, Peptide> PeptideModifiedSequences;
         public readonly Dictionary<string, ProteinGroup> ProteinGroups;
         public readonly Dictionary<SpectraFileInfo, List<ChromatographicPeak>> Peaks;
+        public Dictionary<string, MzLibUtil.UtilProteinGroup> ModInfo { get;  private set; }
         private readonly HashSet<string> _peptideModifiedSequencesToQuantify;
 
         public FlashLfqResults(List<SpectraFileInfo> spectraFiles, List<Identification> identifications, HashSet<string> peptides = null)
@@ -331,6 +334,27 @@
                 }
             }
         }
+        /// <summary>
+        /// Calculate peptide level ptm occupancy with either all peptides to be quantified (by intensity) or a subset of FlashLFQ-identified peptides with an arbitrary peptide-level quantifier.
+        /// </summary>
+        /// <param name="quantifiedPeptides"> Dictionary where keys are string-typed peptide full sequences in PeptideModifiedSequences and the value is a double-typed quantifier of that peptide.</param>
+        /// <param name="IncludeNTerminus"> If true, the index of modifications at the N-terminus will be 0 (zero-based indexing). Otherwise, it is the index of the first amino acid (one-based indexing).</param>
+        /// <param name="IncludeCTerminus"> If true, the index of modifications at the C-terminus will be one more than the index of the last amino acid. Otherwise, it is the index of the last amino acid.</param>
+        /// <returns> Dictionary with the key being the amino acid position of the mod and the value being the string representing the mod</returns>
+        public void CalculatePTMOccupancy(Dictionary<string, double> quantifiedPeptides = null, bool IncludeNTerminus = true, bool IncludeCTerminus = true)
+        {
+            if (quantifiedPeptides == null) quantifiedPeptides = new Dictionary<string, double>();
+
+            var peptides = _peptideModifiedSequencesToQuantify
+                .Where(pep => PeptideModifiedSequences.ContainsKey(pep))
+                .Select(pep => Tuple.Create(
+                    PeptideModifiedSequences[pep].Sequence,
+                    PeptideModifiedSequences[pep].BaseSequence,
+                    PeptideModifiedSequences[pep].ProteinGroups.Select(pg => pg.ProteinGroupName).ToList(),
+                    quantifiedPeptides.GetValueOrDefault(pep, PeptideModifiedSequences[pep].GetTotalIntensity()))).ToList();
+
+            ModInfo = PositionFrequencyAnalysis.PeptidePTMOccupancy(peptides, IncludeNTerminus, IncludeCTerminus);
+        }
 
         /// <summary>
         /// This method uses the median polish algorithm to calculate protein quantities in each biological replicate.
@@ -345,7 +369,7 @@
                 {
                     proteinGroup.Value.SetIntensity(file, 0);
                 }
             }
 
             // associate peptide w/ proteins in a dictionary for easy lookup
             List<Peptide> peptides = PeptideModifiedSequences.Values.Where(p => p.UnambiguousPeptideQuant()).ToList();

mzLib/FlashLFQ/FlashLfqEngine.cs

@@ -236,6 +236,9 @@ public FlashLfqResults Run()
             // do top3 protein quantification
             _results.CalculateProteinResultsMedianPolish(UseSharedPeptidesForProteinQuant);
 
+            // calculate ptm occupancy at the peptide level
+            _results.CalculatePTMOccupancy();
+
             // do Bayesian protein fold-change analysis
             if (BayesianProteinQuant)
             {

mzLib/FlashLFQ/Peptide.cs

@@ -1,5 +1,7 @@
-using System.Collections.Generic;
+using Easy.Common.Extensions;
+using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using System.Text;
 
 namespace FlashLFQ
@@ -67,6 +69,18 @@ public void SetIntensity(SpectraFileInfo fileInfo, double intensity)
             }
         }
 
+        public double GetTotalIntensity()
+        {
+            if (Intensities.IsNotNullOrEmpty())
+            {
+                return Intensities.Sum(i => i.Value);
+            }
+            else
+            {
+                return 0;
+            }
+        } 
+
         public DetectionType GetDetectionType(SpectraFileInfo fileInfo)
         {
             if (DetectionTypes.TryGetValue(fileInfo, out DetectionType detectionType))

mzLib/MassSpectrometry/Enums/DissociationType.cs

@@ -109,6 +109,11 @@ public enum DissociationType
         /// </summary>
         LowCID,
 
+        /// <summary>
+        /// activated ion electron photo detachment dissociation
+        /// </summary>
+        aEPD,
+
         Unknown,
         AnyActivationType,
         Custom,

mzLib/MzLibUtil/ClassExtensions.cs

@@ -19,12 +19,91 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using System.Text.RegularExpressions;
 
 namespace MzLibUtil
 {
     public static class ClassExtensions
     {
+        /// <summary>
+        /// Parses the full sequence to identify mods.
+        /// </summary>
+        /// <param name="fullSequence"> Full sequence of the peptide in question</param>
+        /// <param name="modOnNTerminus"> If true, the index of modifications at the N-terminus will be 0 (zero-based indexing). Otherwise, it is the index of the first amino acid (one-based indexing).</param>
+        /// <param name="modOnCTerminus"> If true, the index of modifications at the C-terminus will be one more than the index of the last amino acid. Otherwise, it is the index of the last amino acid.</param>
+        /// <returns> Dictionary with the key being the amino acid position of the mod and the value being the string representing the mod</returns>
+        public static Dictionary<int, List<string>> ParseModifications(this string fullSequence, bool modOnNTerminus=false, bool modOnCTerminus=false)
+        {
+            // use a regex to get all modifications
+            string pattern = @"\[(.+?)\](?<!\[I+\])"; //The "look-behind" condition prevents matching ] for metal ion modifications
+            Regex regex = new(pattern);
+
+            // remove each match after adding to the dict. Otherwise, getting positions
+            // of the modifications will be rather difficult.
+            //int patternMatches = regex.Matches(fullSequence).Count;
+            Dictionary<int, List<string>> modDict = new();
+
+            MatchCollection matches = regex.Matches(fullSequence);
+            int captureLengthSum = 0;
+            foreach (Match match in matches)
+            {
+                GroupCollection group = match.Groups;
+                string val = group[1].Value;
+                int startIndex = group[0].Index;
+                int captureLength = group[0].Length;
+
+                List<string> modList = new List<string>();
+                modList.Add(val);
+
+                // The position of the amino acids is tracked by the positionToAddToDict variable. It takes the 
+                // startIndex of the modification Match and removes the cumulative length of the modifications
+                // found (including the brackets). The difference will be the number of nonmodification characters, 
+                // or the number of amino acids prior to the startIndex in the sequence. 
+                int positionToAddToDict = startIndex - captureLengthSum;
+
+                // Handle N terminus indexing
+                if ((positionToAddToDict == 0) && !modOnNTerminus)
+                {
+                    positionToAddToDict++;
+                }
+
+                // Handle C terminus indexing
+                if ((fullSequence.Length == startIndex + captureLength) && modOnCTerminus)
+                {
+                    positionToAddToDict++;
+                }
+
+                // check to see if key already exist
+                // if the already key exists, update the current position with the capture length + 1.
+                // otherwise, add the modification to the dict.
+                if (modDict.ContainsKey(positionToAddToDict))
+                {
+                    modDict[positionToAddToDict].Add(val);
+                }
+                else
+                {
+                    modDict.Add(positionToAddToDict, modList);
+                }
+                captureLengthSum += captureLength;
+            }
+            return modDict;
+        }
+
+        /// <summary>
+        /// Fixes an issue where the | appears and throws off the numbering if there are multiple mods on a single amino acid.
+        /// </summary>
+        /// <param name="fullSequence"></param>
+        /// <param name="replacement"></param>
+        /// <param name="specialCharacter"></param>
+        /// <returns></returns>
+        public static void RemoveSpecialCharacters(ref string fullSequence, string replacement = @"", string specialCharacter = @"\|")
+        {
+            // next regex is used in the event that multiple modifications are on a missed cleavage Lysine (K)
+            Regex regexSpecialChar = new(specialCharacter);
+            fullSequence = regexSpecialChar.Replace(fullSequence, replacement);
+        }
+
         public static double[] BoxCarSmooth(this double[] data, int points)
         {
             // Force to be odd

mzLib/MzLibUtil/MzLibException.cs

@@ -3,11 +3,6 @@
 namespace MzLibUtil
 {
     [Serializable]
-    public class MzLibException : Exception
-    {
-        public MzLibException(string message)
-            : base(message)
-        {
-        }
-    }
+    public class MzLibException(string message, Exception innerException = null) 
+        : Exception(message, innerException);
 }

mzLib/MzLibUtil/MzLibUtil.csproj

@@ -16,5 +16,4 @@
     <PackageReference Include="MathNet.Numerics" Version="5.0.0" />
     <PackageReference Include="Microsoft.Win32.Registry" Version="5.0.0" />
   </ItemGroup>
-
 </Project>