Merge branch 'IsoTrackerSpeedup' of https://github.com/Alexander-Sol/mzLib into IsoTrackerSpeedup

Author: Alexander-Sol

mzLib/MassSpectrometry/MsDataFile.cs

@@ -28,6 +28,7 @@ namespace MassSpectrometry
     /// </summary>
     public abstract class MsDataFile : IEnumerable<MsDataScan>
     {
+        protected readonly object DynamicReadingLock = new();
         public MsDataScan[] Scans { get; protected set; }
         public SourceFile SourceFile { get; set; }
         public int NumSpectra => Scans?.Length ?? 0;

mzLib/MassSpectrometry/PeakIndexing/PeakSpline/Bspline.cs

@@ -0,0 +1,121 @@
+using Easy.Common.Extensions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using static System.Runtime.InteropServices.JavaScript.JSType;
+using MzLibUtil;
+
+namespace MassSpectrometry
+{
+    /// <summary>
+    /// This Bspline class is copied from DIA-Umpire code. It is a more generalized spline that allows different smoothing degrees.
+    /// In theory, it could replace linear and cubic spline where the smoothing degree is explicitly set to 1 and 3 respectively.
+    /// Only used for RT-based spline for now.
+    /// </summary>
+    public class Bspline : XicSpline
+    {
+        public int SmoothDegree { get; set; }
+        public int NumberOfPoints { get; set; }
+
+        public Bspline(int smoothDegree, int numberOfPoints)
+        {
+            SmoothDegree = smoothDegree;
+            NumberOfPoints = numberOfPoints;
+        }
+
+        public override (double, double)[] GetXicSplineData(float[] rtArray, float[] intensityArray, double start = -1, double end = -1)
+        {
+            List<(double, double)> bsplineCollection = new List<(double, double)>();
+            int p = SmoothDegree;
+            int n = rtArray.Length - 1;
+            int m = rtArray.Length + p;
+
+            if (rtArray.Length <= p)
+            {
+                throw new MzLibException("The number of points in the input array must be greater than the degree of the Bspline.");
+            }
+
+            float[] bspline_T_ = new float[m + p];
+            for (int i = 0; i <= n; i++)
+            {
+                bspline_T_[i] = 0;
+                bspline_T_[m - i] = 1;
+            }
+            float intv = 1.0f / (m - 2 * p);
+            for (int i = 1; i <= m - 1; i++)
+            {
+                bspline_T_[p + i] = bspline_T_[p + i - 1] + intv;
+            }
+            for (int i = 0; i < NumberOfPoints; i++)
+            {
+                float t = (float)i / NumberOfPoints;
+                var pt = getbspline(rtArray, intensityArray, t, n, p, bspline_T_);
+                bsplineCollection.Add(pt);
+            }
+            if (bsplineCollection[bsplineCollection.Count() - 1].Item1 < rtArray[rtArray.Length - 1])
+            {
+                bsplineCollection.Add((rtArray[rtArray.Length - 1], intensityArray[intensityArray.Length - 1]));
+            }
+            if (bsplineCollection[0].Item1 > rtArray[0])
+            {
+                bsplineCollection.Add((rtArray[0], intensityArray[0]));
+            }
+            return bsplineCollection.ToArray();
+        }
+
+        public (float, float) getbspline(float[] rtArray, float[] intensityArray, float t, int n, int p, float[] bspline_T_)
+        {
+            float x = 0, y = 0;
+            for (int i = 0; i <= n; i++)
+            {
+                float a = bspline_base(i, p, t, bspline_T_);
+                x += rtArray[i] * a;
+                y += intensityArray[i] * a;
+            }
+            return new(x, y);
+        }
+
+        public float bspline_base(int i, int p, float t, float[] bspline_T_)
+        {
+            float n, c1, c2;
+            float tn1 = 0;
+            float tn2 = 0;
+            if (p == 0)
+            {
+                if (bspline_T_[i] <= t && t < bspline_T_[i + 1] && bspline_T_[i] < bspline_T_[i + 1])
+                {
+                    n = 1;
+                }
+                else
+                {
+                    n = 0;
+                }
+            }
+            else
+            {
+                if (bspline_T_[i + p] - bspline_T_[i] == 0)
+                {
+                    c1 = 0;
+                }
+                else
+                {
+                    tn1 = bspline_base(i, p - 1, t, bspline_T_);
+                    c1 = (t - bspline_T_[i]) / (bspline_T_[i + p] - bspline_T_[i]);
+                }
+                if (bspline_T_[i + p + 1] - bspline_T_[i + 1] == 0)
+                {
+                    c2 = 0;
+                }
+                else
+                {
+                    tn2 = bspline_base(i + 1, p - 1, t, bspline_T_);
+                    c2 = (bspline_T_[i + p + 1] - t) / (bspline_T_[i + p + 1] - bspline_T_[i + 1]);
+                }
+                n = c1 * tn1 + c2 * tn2;
+            }
+            return n;
+        }
+    }
+}

mzLib/MassSpectrometry/PeakIndexing/PeakSpline/XicSpline.cs

@@ -6,6 +6,8 @@
 using System.Text;
 using System.Threading.Tasks;
 using MathNet.Numerics;
+using System.Numerics;
+using MathNet.Numerics.LinearAlgebra;
 
 namespace MassSpectrometry
 {
@@ -52,16 +54,16 @@ public void SetXicSplineXYData(ExtractedIonChromatogram xic, bool cycle = false,
             }
             else
             {
-                peakRts = xic.Peaks.Select(p => (float)p.RetentionTime).ToArray();
+                peakRts = xic.Peaks.Select(p => p.RetentionTime).ToArray();
             }
-            var peakIntensities = xic.Peaks.Select(p => (float)p.Intensity).ToArray();
+            var peakIntensities = xic.Peaks.Select(p => p.Intensity).ToArray();
             xic.XYData = GetXicSplineData(peakRts, peakIntensities, start, end);
         }
 
         /// <summary>
         /// Check if the input arrays meet the requirements of interpolation.
         /// </summary>
-        protected void CheckArrays(double[] rtArray, double[] intensityArray)
+        protected void CheckArrays<T>(T[] rtArray, T[] intensityArray) where T : INumber<T>
         {
             if (rtArray.Length != intensityArray.Length)
             {

mzLib/MzIdentML/mzIdentML1_1_0.cs

@@ -22,8 +22,8 @@ namespace mzIdentML110.Generated
     [System.SerializableAttribute()]
     [System.Diagnostics.DebuggerStepThroughAttribute()]
     [System.ComponentModel.DesignerCategoryAttribute("code")]
-    [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://psidev.info/psi/pi/mzIdentML/1.1")]
-    [System.Xml.Serialization.XmlRootAttribute("MzIdentML", Namespace = "http://psidev.info/psi/pi/mzIdentML/1.1", IsNullable = false)]
+    [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://psidev.info/psi/pi/mzIdentML/1.1.0")]
+    [System.Xml.Serialization.XmlRootAttribute("MzIdentML", Namespace = "http://psidev.info/psi/pi/mzIdentML/1.1.0", IsNullable = false)]
     public partial class MzIdentMLType110 : IdentifiableType
     {
 

mzLib/Omics/IBioPolymerWithSetMods.cs

@@ -1,4 +1,5 @@
 using System.Text;
+using System.Text.RegularExpressions;
 using Chemistry;
 using MassSpectrometry;
 using Omics.Digestion;
@@ -197,5 +198,28 @@ public static string DetermineFullSequence(string baseSequence, IDictionary<int,
 
             return subSequence.ToString();
         }
+
+        public static string ParseSubstitutedFullSequence(string fullSequenceWithSubstitution)
+        {
+            string pattern = @"\[\d+\+?\s*nucleotide substitution:\s*([A-Z])->([A-Z]) on ([A-Z])\]";
+            string parsedSequence = fullSequenceWithSubstitution;
+            var match = Regex.Match(parsedSequence, pattern);
+            while (match.Success)
+            {
+                string original = match.Groups[1].Value; // Z (original)
+                string sub = match.Groups[2].Value;   // Y (substitute)
+                int patternIndex = match.Index;
+                int replaceIndex = parsedSequence.LastIndexOf(original, patternIndex);
+                if (replaceIndex != -1)
+                {
+                    // Replace the first occurrence of Z before the pattern with Y
+                    parsedSequence = parsedSequence.Remove(replaceIndex, 1).Insert(replaceIndex, sub);
+                }
+                // Remove the pattern
+                parsedSequence = parsedSequence.Remove(patternIndex, match.Length);
+                match = Regex.Match(parsedSequence, pattern); // Find the next match
+            }
+            return parsedSequence;
+        }
     }
 }

mzLib/Readers/Bruker/BrukerFileReader.cs

@@ -1,11 +1,9 @@
-using System.Collections.ObjectModel;
-using System.Runtime.InteropServices;
+using System.Runtime.InteropServices;
 using System.Text;
 using MassSpectrometry;
 using System.Data.SQLite;
 using Easy.Common.Extensions;
 using MzLibUtil;
-using UsefulProteomicsDatabases;
 
 namespace Readers
 {
@@ -94,10 +92,14 @@ public override SourceFile GetSourceFile()
             return new SourceFile(nativeIdFormat, massSpecFileFormat,
 				null, null, id: null, filePath: fileName);
         }
-		public override MsDataScan GetOneBasedScanFromDynamicConnection(int oneBasedScanNumber, IFilteringParams? filterParams = null)
+
+        public override MsDataScan GetOneBasedScanFromDynamicConnection(int oneBasedScanNumber, IFilteringParams? filterParams = null)
 		{
-			return GetMsDataScanDynamic(oneBasedScanNumber, filterParams); 
-		}
+            lock (DynamicReadingLock)
+            {
+                return GetMsDataScanDynamic(oneBasedScanNumber, filterParams);
+            }
+        }
 
 		public override void CloseDynamicConnection()
 		{

mzLib/Readers/InternalResults/ResultFiles/SpectrumMatchTsvReader.cs

@@ -16,74 +16,66 @@ public static class SpectrumMatchTsvReader
         /// <exception cref="ArgumentOutOfRangeException"></exception>
         public static List<T> ReadTsv<T>(string filePath, out List<string> warnings) where T : SpectrumMatchFromTsv
         {
-            List<T> psms = new List<T>();
-            warnings = new List<string>();
-
-            StreamReader reader = null;
+            string[] lines;
             try
             {
-                reader = new StreamReader(filePath);
+                lines = File.ReadAllLines(filePath);
             }
             catch (Exception e)
             {
                 throw new MzLibException("Could not read file: " + e.Message, e);
             }
 
-            int lineCount = 0;
-
-            string line;
-            Dictionary<string, int> parsedHeader = null;
             MzLibException? parsingException = null;
-
-            while (reader.Peek() > 0)
+            SupportedFileType type;
+            try
             {
-                lineCount++;
-
-                line = reader.ReadLine();
+                type = filePath.ParseFileType();
+            }
+            catch (MzLibException e)
+            {
+                // if the parsing fails due to file path not being in the correct format, assume Psm reader will work. 
+                parsingException = e;
+                type = SupportedFileType.psmtsv;
+            }
+            Dictionary<string, int> parsedHeader = ParseHeader(lines[0]);
+            int lineCount = lines.Length - 1; // Exclude header
 
-                if (lineCount == 1)
-                {
-                    parsedHeader = ParseHeader(line);
-                    continue;
-                }
+            // Pre-allocate result array
+            T?[] psmsArray = new T[lineCount];
+            var warningsBag = new System.Collections.Concurrent.ConcurrentBag<string>();
 
+            Parallel.For(1, lines.Length, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }, i =>
+            {
+                var line = lines[i];
                 try
                 {
-                    SupportedFileType type;
-                    try
-                    {
-                        type = filePath.ParseFileType();
-                    }
-                    catch (MzLibException e)
+                    T result = type switch
                     {
-                        // if the parsing fails due to file path not being in the correct format, assume Psm reader will work. 
-                        parsingException = e;
-                        type = SupportedFileType.psmtsv;
-                    }
-
-                    switch (type)
-                    {
-                        case SupportedFileType.osmtsv:
-                            psms.Add((T)(SpectrumMatchFromTsv)new OsmFromTsv(line, Split, parsedHeader));
-                            break;
-
-                        case SupportedFileType.psmtsv:
-                        default:
-                            psms.Add((T)(SpectrumMatchFromTsv)new PsmFromTsv(line, Split, parsedHeader));
-                            break;
-                    }
+                        SupportedFileType.osmtsv => (T)(SpectrumMatchFromTsv)new OsmFromTsv(line, Split, parsedHeader),
+                        _ => (T)(SpectrumMatchFromTsv)new PsmFromTsv(line, Split, parsedHeader)
+                    };
+                    psmsArray[i - 1] = result; // -1 to align with result array (excluding header)
                 }
                 catch (Exception)
                 {
-                    warnings.Add("Could not read line: " + lineCount);
+                    warningsBag.Add("Could not read line: " + (i + 1)); // plus one to account for header line
                 }
-            }
+            });
 
-            reader.Close();
+            var psms = new List<T>(lineCount);
+            foreach (var x in psmsArray)
+            {
+                if (x is not null)
+                {
+                    psms.Add(x);
+                }
+            }
+            warnings = warningsBag.ToList();
 
-            if (lineCount - 1 != psms.Count)
+            if (lineCount != psms.Count)
             {
-                warnings.Add("Warning: " + (lineCount - 1 - psms.Count) + " PSMs were not read.");
+                warnings.Add("Warning: " + (lineCount - psms.Count) + " PSMs were not read.");
             }
 
             // if we could not parse type, we assumed PSMs were in the file.