IsoTracker: The quantification tool for isobaric peaks in Match-between-runs (smith-chem-wisc#832)

* sapce

* remove space

* add alex project

* add test xic

* replace flashlfq engine

* update PeakIndexingEngine

* add testRawFileReader

* extend the TestMzML

* add Threading Test

* revised FlashLFQReuslt and FlashLfQEngine (remove the ploty)

* revise the Peptide:

SetRentionTime
SetIsobaricpeptide

* add the MovedIdentifications

* revised ChromatographicPeak

* add the tester in TestRawfileReader

* Update 2/19/20025
1. Delete some unused function in XIC and XICgroup
2. Revise the BuildIdList function in XICgroup, avoid the depulicated situation
3. FlashLFQEngine: I do the XIC reference picking after XIC group building.
4. For the FlashLFQResult: revised the writing function about the IsoDict (even the count is 1)
5. Add the new function "SetMbrPeptide" for one peak in IsoDict
6. Add the detetionType label for IsobaricPeak
7. Add the testing for David_data

* Output function updating
In order to merge isopeak into isopeptide and protein group
I made two function for merging it.
AddIsoPeaks: Iterate through the Dict and put the isopeak into the _Peaks
RevisedPeptide: Extracted the Isopeptide into the _PeptideWithModified

* Update:
try to output the quantified Protein and quntified Peptide file

* Update 3/6/2025:
Remove the local folders. files and associated tester for PR.

* Delete the parallelSearch and ThreadingTest

* change the tostringTester
Because I add the new row (retention time) in the peptide output file.

* Delete the unused testing  "SnipMzMl"

* Change the XIC folder name to "IsoTracker"
Output option : IsoTracker and NonIsoTracker

* Fix the output problem

* Update to be ready to Merge
1. Revise some variable to be more readable
2. Add the unit test for XIC and XIC grouped

* Comment the FlashLFQ testing with local folder and files

* Add the output Testing
(1) Check the QuantifiedPeptide header
(2) Make a searching task went through IsoTracker code

* Add the tester

* change

* change

* Add the new Tester for converaging testing, detail informations are following:
(1) Two snipped raw files are sitmulated for isobaric case
(2) Pruned Psms file (only three isobaric peptides are included)
(3) Checking the new Quantified file header (with RT information)
(4) Checking only modified peptide can be Isobaric peptide

* Add the TestFixture to avoid the codeCoverage Testing

* Add TestFixture
System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage

* Fixtext for the converage

* Deleted some unuseful package and line

* Deleted the Big tester

* Add the tester description

* Deleted the unused package in TestRawFileReader

* Some changes
(1) idGroupedBySe is grouped by base sequence and mass
(2) revise the code according to the comment
(3)Clean up some unuseful code and using package
(4)Add four testers for ambiguous ID

* Debug
(1) the "Equal" function for Identification should be used exclusively for Isotracker. So I add a private function "IsoEqual" and "IdsEqual"
(2)TestOutputToCustomDirectoryAndNameMzML: clean the existed file in this directory

* small commit

* Fixed the confict

* testing the new branch name

* Clean up the line

* Debug
(1) For ambiguity recognition: skip the duplicated id with the same modifiedSequence
(2) Take care the null peak in IsoPeptideDict

* Clean up the code line

* Resolve comment
(1) equal and getHashCode for PeakRegion
(2) deleted the protein group checking for IsoEqual
(3) Rename the tester
(4) Rearragne the tester
(5) fix the type

* Debug
(1) Filter out the DecoyId when doing the IsoTracker
(2) Improve the peptide output files, if only peak was detected, then we don't view it like Isobaric peptide.

* Fix the bug while the IsoTracker and MBR are on
(1) IndexEngine should not be serlize when the IsoTracker is turned on

* Debug
(1) Avoid to deserialize the indexEngine while IsoTracker is on.
(2) Add the tester for combining searching options

* Resolve the comment
(1) Add IEquatable interface into MoveId, PeakRegion and ChromatographicPeak

* Fix the version number

---------

Co-authored-by: Nic Bollis <[email protected]>

Author: RayMSMS

mzLib/FlashLFQ/ChromatographicPeak.cs

@@ -7,7 +7,7 @@
 
 namespace FlashLFQ
 {
-    public class ChromatographicPeak
+    public class ChromatographicPeak : IEquatable<ChromatographicPeak>
     {
         public double Intensity;
         public double ApexRetentionTime => Apex?.IndexedPeak.RetentionTime ?? -1;
@@ -16,6 +16,8 @@ public class ChromatographicPeak
         public int ScanCount => IsotopicEnvelopes.Count;
         public double SplitRT;
         public readonly bool IsMbrPeak;
+        public DetectionType DetectionType { get; set; }
+        public double PredictedRetentionTime { get; init; }
         public double MbrScore;
         public double PpmScore { get; set; }
         public double IntensityScore { get; set; }
@@ -46,6 +48,33 @@ public ChromatographicPeak(Identification id, bool isMbrPeak, SpectraFileInfo fi
             RandomRt = randomRt;
         }
 
+        /// <summary>
+        /// overloaded constructor for Isobaric_ambiguity peaks. In this case, the peak is identified by multiple identifications
+        /// </summary>
+        /// <param name="ids"></param>
+        /// <param name="isMbrPeak"></param>
+        /// <param name="fileInfo"></param>
+        /// <param name="randomRt"></param>
+        public ChromatographicPeak(List<Identification> ids, bool isMbrPeak, SpectraFileInfo fileInfo, double predictedRetentionTime, DetectionType detectionType = DetectionType.Imputed) :
+            this(null, isMbrPeak, fileInfo)
+        {
+            PredictedRetentionTime = predictedRetentionTime;
+            DetectionType = detectionType; // default to imputed
+            Identifications = ids;
+        }
+
+        public ChromatographicPeak(Identification id, bool isMbrPeak, SpectraFileInfo fileInfo, double predictedRetentionTime, DetectionType detectionType = DetectionType.Default) :
+            this(id, isMbrPeak, fileInfo)
+        {
+            PredictedRetentionTime = predictedRetentionTime;
+            DetectionType = detectionType; // default to imputed
+
+            if (detectionType == DetectionType.Default && isMbrPeak)
+            {
+                DetectionType = DetectionType.MBR;
+            }
+        }
+
         public bool Equals(ChromatographicPeak peak)
         {
             return SpectraFileInfo.Equals(peak.SpectraFileInfo) 
@@ -240,7 +269,18 @@ public override string ToString()
 
             sb.Append("" + NumChargeStatesObserved + "\t");
 
-            if (IsMbrPeak)
+            // temporary way to distinguish between MBR, MBR_IsoTrack, IsoTrack_Ambiguous and MSMS peaks
+            if (IsMbrPeak && DetectionType == DetectionType.IsoTrack_MBR)
+            {
+                sb.Append("" + "MBR_IsoTrack" + "\t");
+            }
+
+            else if (IsMbrPeak && DetectionType == DetectionType.IsoTrack_Ambiguous)
+            {
+                sb.Append("" + "IsoTrack_Ambiguous" + "\t");
+            }
+
+            else if (IsMbrPeak)
             {
                 sb.Append("" + "MBR" + "\t");
             }

mzLib/FlashLFQ/DetectionType.cs

@@ -4,9 +4,12 @@ public enum DetectionType
     {
         MSMS,
         MBR,
+        IsoTrack_MBR, // MBR detected by IsoTrack
+        IsoTrack_Ambiguous, // Ambiguous(more than two Id in one peak) detected by IsoTrack
         NotDetected,
         MSMSAmbiguousPeakfinding,
         MSMSIdentifiedButNotQuantified,
-        Imputed
+        Imputed,
+        Default // Default value, will be removed in the future
     }
 }

mzLib/FlashLFQ/FlashLFQResults.cs

@@ -5,28 +5,32 @@
 using System.IO;
 using System.Linq;
 using System.Text;
+using FlashLFQ.IsoTracker;
 
 namespace FlashLFQ
 {
     public class FlashLfqResults
     {
+        public bool IsoTracker = false;
         public readonly List<SpectraFileInfo> SpectraFiles;
         public readonly Dictionary<string, Peptide> PeptideModifiedSequences;
         public readonly Dictionary<string, ProteinGroup> ProteinGroups;
         public readonly Dictionary<SpectraFileInfo, List<ChromatographicPeak>> Peaks;
         private readonly HashSet<string> _peptideModifiedSequencesToQuantify;
+        public Dictionary<string, Dictionary<PeakRegion, List<ChromatographicPeak>>> IsobaricPeptideDict = null;
         public string PepResultString { get; set; }
         public double MbrQValueThreshold { get; set; }
 
         public FlashLfqResults(List<SpectraFileInfo> spectraFiles, List<Identification> identifications, double mbrQValueThreshold = 0.05,
-            HashSet<string> peptideModifiedSequencesToQuantify = null)
+            HashSet<string> peptideModifiedSequencesToQuantify = null, bool isIsoTracker = false)
         {
             SpectraFiles = spectraFiles;
             PeptideModifiedSequences = new Dictionary<string, Peptide>();
             ProteinGroups = new Dictionary<string, ProteinGroup>();
             Peaks = new Dictionary<SpectraFileInfo, List<ChromatographicPeak>>();
             MbrQValueThreshold = mbrQValueThreshold;
             _peptideModifiedSequencesToQuantify = peptideModifiedSequencesToQuantify ?? identifications.Where(id => !id.IsDecoy).Select(id => id.ModifiedSequence).ToHashSet();
+            IsoTracker = isIsoTracker;
 
             foreach (SpectraFileInfo file in spectraFiles)
             {
@@ -131,9 +135,11 @@ public void CalculatePeptideResults(bool quantifyAmbiguousPeptides)
                 {
                     sequence.Value.SetDetectionType(file, DetectionType.NotDetected);
                     sequence.Value.SetIntensity(file, 0);
+                    sequence.Value.SetRetentionTime(file,0);
                 }
             }
 
+
             foreach (var filePeaks in Peaks)
             {
                 var groupedPeaks = filePeaks.Value
@@ -142,13 +148,13 @@ public void CalculatePeptideResults(bool quantifyAmbiguousPeptides)
                     .Where(p => !p.IsMbrPeak || (p.MbrQValue < MbrQValueThreshold && !p.RandomRt))
                     .GroupBy(p => p.Identifications.First().ModifiedSequence)
                     .Where(group => _peptideModifiedSequencesToQuantify.Contains(group.Key))
-                    .ToList();
+                    .ToDictionary(p => p.Key, p => p.ToList());
 
                 foreach (var sequenceWithPeaks in groupedPeaks)
                 {
                     string sequence = sequenceWithPeaks.Key;
-                    double intensity = sequenceWithPeaks.Max(p => p.Intensity);
-                    ChromatographicPeak bestPeak = sequenceWithPeaks.First(p => p.Intensity == intensity);
+                    double intensity = sequenceWithPeaks.Value.Max(p => p.Intensity);
+                    ChromatographicPeak bestPeak = sequenceWithPeaks.Value.First(p => p.Intensity == intensity);
                     DetectionType detectionType;
 
                     if (bestPeak.IsMbrPeak && intensity > 0)
@@ -169,6 +175,7 @@ public void CalculatePeptideResults(bool quantifyAmbiguousPeptides)
                     }
 
                     PeptideModifiedSequences[sequence].SetIntensity(filePeaks.Key, intensity);
+                    PeptideModifiedSequences[sequence].SetRetentionTime(filePeaks.Key, bestPeak.ApexRetentionTime);
                     PeptideModifiedSequences[sequence].SetDetectionType(filePeaks.Key, detectionType);
                 }
 
@@ -195,6 +202,7 @@ public void CalculatePeptideResults(bool quantifyAmbiguousPeptides)
                             if (Math.Abs(alreadyRecordedIntensity) < 0.01)
                             {
                                 PeptideModifiedSequences[sequence].SetDetectionType(filePeaks.Key, DetectionType.MSMSAmbiguousPeakfinding);
+                                PeptideModifiedSequences[sequence].SetRetentionTime(filePeaks.Key, ambiguousPeak.ApexRetentionTime);
                                 PeptideModifiedSequences[sequence].SetIntensity(filePeaks.Key, ambiguousPeak.Intensity);
                             }
                             // If the peptide intensity has already been recorded, that value is retained. 
@@ -207,12 +215,19 @@ public void CalculatePeptideResults(bool quantifyAmbiguousPeptides)
                         {
                             PeptideModifiedSequences[sequence].SetDetectionType(filePeaks.Key, DetectionType.MSMSAmbiguousPeakfinding);
                             PeptideModifiedSequences[sequence].SetIntensity(filePeaks.Key, 0);
+                            PeptideModifiedSequences[sequence].SetRetentionTime(filePeaks.Key, ambiguousPeak.ApexRetentionTime);
                         }
                     }
                 }
 
             }
 
+            if (IsoTracker && IsobaricPeptideDict != null)
+            {
+                // We view each Isobaric peak as an individual peptide, so we need to add them to the peptide list
+                RevisedModifiedPeptides();
+            }
+
             if (!quantifyAmbiguousPeptides)
             {
                 HandleAmbiguityInFractions();
@@ -591,11 +606,24 @@ public void WriteResults(string peaksOutputPath, string modPeptideOutputPath, st
             {
                 using (StreamWriter output = new StreamWriter(modPeptideOutputPath))
                 {
-                    output.WriteLine(Peptide.TabSeparatedHeader(SpectraFiles));
-
-                    foreach (var peptide in PeptideModifiedSequences.OrderBy(p => p.Key))
+                    if (IsoTracker)
+                    {
+                        output.WriteLine(Peptide.TabSeparatedHeader_IsoTracker(SpectraFiles));
+                        // we want to output with same iso group index followed by peak order.
+                        foreach (var peptide in PeptideModifiedSequences
+                                     .OrderBy(p => p.Value.IsoGroupIndex ?? int.MaxValue)
+                                     .ThenBy(p => p.Value.PeakOrder ?? int.MinValue))
+                        {
+                            output.WriteLine(peptide.Value.ToString(SpectraFiles, IsoTracker));
+                        }
+                    }
+                    else
                     {
-                        output.WriteLine(peptide.Value.ToString(SpectraFiles));
+                        output.WriteLine(Peptide.TabSeparatedHeader(SpectraFiles));
+                        foreach (var peptide in PeptideModifiedSequences.OrderBy(p => p.Key))
+                        {
+                            output.WriteLine(peptide.Value.ToString(SpectraFiles, IsoTracker));
+                        }
                     }
                 }
             }
@@ -759,5 +787,71 @@ public static void MedianPolish(double[][] table, int maxIterations = 10, double
                 sumAbsoluteResiduals = iterationSumAbsoluteResiduals;
             }
         }
+
+        /// <summary>
+        /// This method is used to re-edit the peptide List by adding the isobaric peptides and remove the former peptide.
+        /// </summary>
+        internal void RevisedModifiedPeptides()
+        {
+            int isoGroupIndex = 1;
+            //If the isobaric peptide dictionary is not empty, then we need to revise the peptide list.
+            foreach (var isoPeptides in IsobaricPeptideDict.Where(p=>p.Value.Count != 0)) 
+            {
+                string peptideSequence = isoPeptides.Key;
+                Peptide originalPeptide = PeptideModifiedSequences[peptideSequence];
+
+                // Remove the formal peptide from the peptide list
+                var allIDs = isoPeptides.Value.Values
+                    .SelectMany(p => p)
+                    .Where(p => p != null)
+                    .SelectMany(p=>p.Identifications)
+                    .DistinctBy(p=>p.ModifiedSequence)
+                    .Select(p=>p.ModifiedSequence)
+                    .ToList();
+                foreach (var modSeq in allIDs)
+                {
+                    if (PeptideModifiedSequences.ContainsKey(modSeq))
+                    {
+                        PeptideModifiedSequences.Remove(modSeq);
+                    }
+                }
+
+                // Add the isobaric peptides to the peptide list
+
+                //If there is only one peak for the isobaric peptides, then we don't view them as isobaric peptides.
+                if (isoPeptides.Value.Values.Count == 1)
+                {
+                    var isoPeptidePeaks = isoPeptides.Value.Values.First();
+                    var allSeq = isoPeptidePeaks
+                        .Where(p => p != null)
+                        .SelectMany(p => p.Identifications)
+                        .Select(p => p.ModifiedSequence)
+                        .Distinct()
+                        .ToList();
+                    Peptide peptide = new Peptide(string.Join(" | ", allSeq), originalPeptide.BaseSequence, originalPeptide.UseForProteinQuant, originalPeptide.ProteinGroups);
+                    peptide.SetIsobaricPeptide(isoPeptidePeaks); //When we set the peptide as IsobaricPeptide, then the retention time, intensity and detectionType will be set from the chromPeak automatically.
+                    PeptideModifiedSequences[peptide.Sequence] = peptide;
+                }
+                //If there are multiple peaks for the isobaric peptides, then we view them as isobaric peptides.
+                else
+                {
+                    int peakIndex = 1;
+                    foreach (var isoPeptidePeaks in isoPeptides.Value.Values.ToList())
+                    {
+                        var allSeq = isoPeptidePeaks
+                            .Where(p => p != null)
+                            .SelectMany(p => p.Identifications)
+                            .Select(p => p.ModifiedSequence)
+                            .Distinct()
+                            .ToList();
+                        Peptide peptide = new Peptide(string.Join(" | ", allSeq) + " Isopeptide_peak" + peakIndex, originalPeptide.BaseSequence, originalPeptide.UseForProteinQuant, originalPeptide.ProteinGroups, isoGroupIndex, peakIndex);
+                        peptide.SetIsobaricPeptide(isoPeptidePeaks); //When we set the peptide as IsobaricPeptide, then the retention time, intensity and detectionType will be set from the chromPeak automatically.
+                        PeptideModifiedSequences[peptide.Sequence] = peptide;
+                        peakIndex++;
+                    }
+                    isoGroupIndex++;
+                }
+            }
+        }
     }
 }